@glowlabs-org/utils 0.2.95 → 0.2.97

package/dist/cjs/{farms-router-DCCy-acA.js → farms-router-CDsqKkP6.js}

@@ -209,6 +209,8 @@ const mainnetAddresses = {
     USDG_UNISWAP: "0xe010ec500720bE9EF3F82129E7eD2Ee1FB7955F2",
     GLW_UNISWAP: "0xf4fbC617A5733EAAF9af08E1Ab816B103388d8B6",
     FORWARDER: "0x240CBe07a047ce484DCa2E3Ae15d4907Aba41BE2",
+    OFFCHAIN_FRACTIONS: "0x1Eca5C4391f10097C3232a0672e83c60A7dab7cD", // TODO: change to mainnet address
+    COUNTERFACTUAL_HOLDER_FACTORY: "0x2c3AB887746F6f4a8a4b9Db6aC800eb71945509A", // TODO: change to mainnet address
     FOUNDATION_WALLET: "0xc5174BBf649a92F9941e981af68AaA14Dd814F85",
     UNISWAP_V2_ROUTER: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
     UNISWAP_V2_FACTORY: "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f",
@@ -223,6 +225,8 @@ const sepoliaAddresses = {
     USDG_UNISWAP: "0x2a085A3aEA8982396533327c854753Ce521B666d",
     GLW_UNISWAP: "0x8e27016D0B866a56CE74A1a280c749dD679bb0Fa",
     FORWARDER: "0xDaC24F18171224eeaf6a9B38f5C5081aDbDff969",
+    OFFCHAIN_FRACTIONS: "0x1Eca5C4391f10097C3232a0672e83c60A7dab7cD",
+    COUNTERFACTUAL_HOLDER_FACTORY: "0x2c3AB887746F6f4a8a4b9Db6aC800eb71945509A",
     FOUNDATION_WALLET: "0x5e230FED487c86B90f6508104149F087d9B1B0A7",
     UNISWAP_V2_ROUTER: "0xeE567Fe1712Faf6149d80dA1E6934E354124CfE3",
     UNISWAP_V2_FACTORY: "0xF62c03E08ada871A0bEb309762E260a7a6a880E6",
@@ -279,7 +283,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(error) {
+function parseEthersError$1(error) {
     if (!error)
         return "Unknown error";
     const possibleError = error;
@@ -306,7 +310,7 @@ function parseEthersError(error) {
     return exports.ForwarderError.UNKNOWN_ERROR;
 }
 // Type-guard style helper to ensure a signer exists throughout the rest of the function.
-function assertSigner(maybeSigner) {
+function assertSigner$1(maybeSigner) {
     if (!maybeSigner) {
         throw new Error(exports.ForwarderError.SIGNER_NOT_AVAILABLE);
     }
@@ -321,7 +325,7 @@ function useForwarder(signer, CHAIN_ID) {
     };
     // Returns a contract instance for Forwarder
     function getForwarderContract() {
-        assertSigner(signer);
+        assertSigner$1(signer);
         return new ethers.Contract(ADDRESSES.FORWARDER, FORWARDER_ABI, signer);
     }
     /**
@@ -383,7 +387,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Get the appropriate token contract based on currency
      */
     function getTokenContract(currency = "USDC") {
-        assertSigner(signer);
+        assertSigner$1(signer);
         let tokenAddress;
         switch (currency) {
             case "USDC":
@@ -406,7 +410,7 @@ function useForwarder(signer, CHAIN_ID) {
      * @param currency The currency to check allowance for
      */
     async function checkTokenAllowance(owner, currency = "USDC") {
-        assertSigner(signer);
+        assertSigner$1(signer);
         try {
             const tokenContract = getTokenContract(currency);
             if (!tokenContract)
@@ -415,7 +419,7 @@ function useForwarder(signer, CHAIN_ID) {
             return allowance;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseEthersError$1(error));
         }
     }
     /**
@@ -424,7 +428,7 @@ function useForwarder(signer, CHAIN_ID) {
      * @param currency The currency to check balance for
      */
     async function checkTokenBalance(owner, currency = "USDC") {
-        assertSigner(signer);
+        assertSigner$1(signer);
         try {
             const tokenContract = getTokenContract(currency);
             if (!tokenContract)
@@ -433,7 +437,7 @@ function useForwarder(signer, CHAIN_ID) {
             return balance;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseEthersError$1(error));
         }
     }
     /**
@@ -442,7 +446,7 @@ function useForwarder(signer, CHAIN_ID) {
      * @param currency The currency to approve
      */
     async function approveToken(amount, currency = "USDC") {
-        assertSigner(signer);
+        assertSigner$1(signer);
         try {
             const tokenContract = getTokenContract(currency);
             if (!tokenContract)
@@ -454,7 +458,7 @@ function useForwarder(signer, CHAIN_ID) {
             return true;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseEthersError$1(error));
         }
         finally {
             setIsProcessing(false);
@@ -465,7 +469,7 @@ function useForwarder(signer, CHAIN_ID) {
      * @param params Forward parameters including type, amount, and required fields
      */
     async function forwardTokens(params) {
-        assertSigner(signer);
+        assertSigner$1(signer);
         try {
             const forwarderContract = getForwarderContract();
             if (!forwarderContract)
@@ -497,7 +501,7 @@ function useForwarder(signer, CHAIN_ID) {
                     await approveTx.wait();
                 }
                 catch (approveError) {
-                    throw new Error(parseEthersError(approveError) || "Token approval failed");
+                    throw new Error(parseEthersError$1(approveError) || "Token approval failed");
                 }
             }
             // Get the token address based on currency
@@ -534,213 +538,1064 @@ function useForwarder(signer, CHAIN_ID) {
                         : ADDRESSES.FOUNDATION_WALLET, amount, sendToCounterfactualWallet, message, { from: owner });
                 }
             }
+            catch (staticError) {
+                throw new Error(parseEthersError$1(staticError));
+            }
+            // Execute the forward transaction
+            let tx;
+            if (!isAuditFees && currency === "USDC") {
+                tx = await forwarderContract.getFunction("swapUSDCAndForwardUSDG")(amount, ADDRESSES.FOUNDATION_WALLET, sendToCounterfactualWallet, message);
+            }
+            else {
+                tx = await forwarderContract.getFunction("forward")(tokenAddress, isAuditFees
+                    ? ADDRESSES.AUDIT_FEE_WALLET
+                    : ADDRESSES.FOUNDATION_WALLET, amount, sendToCounterfactualWallet, message);
+            }
+            await tx.wait();
+            return tx.hash;
+        }
+        catch (txError) {
+            throw new Error(parseEthersError$1(txError));
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }
+    /**
+     * Forward tokens for protocol fee payment and GCTL minting with staking
+     */
+    async function payProtocolFeeAndMintGCTLAndStake(amount, userAddress, applicationId, regionId, currency = "USDC") {
+        assertSigner$1(signer);
+        // GCTL minting only supports USDC and USDG
+        if (currency === "GLW") {
+            throw new Error("GCTL minting is not supported with GLW payment. Use USDC or USDG.");
+        }
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: TRANSFER_TYPES.PayProtocolFeeAndMintGCTLAndStake,
+            currency,
+            applicationId,
+            regionId,
+        });
+    }
+    /**
+     * Forward tokens for protocol fee payment and GCTL minting with staking
+     */
+    async function sponsorProtocolFeeAndMintGCTLAndStake(amount, userAddress, applicationId, currency = "USDC") {
+        assertSigner$1(signer);
+        if (currency === "GLW") {
+            throw new Error("GCTL minting is not supported with GLW payment. Use USDC or USDG.");
+        }
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: TRANSFER_TYPES.SponsorProtocolFeeAndMintGCTLAndStake,
+            currency,
+            applicationId,
+        });
+    }
+    /**
+     * Forward tokens for protocol fee payment only
+     */
+    async function payProtocolFee(amount, userAddress, applicationId, currency = "USDC") {
+        assertSigner$1(signer);
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: TRANSFER_TYPES.PayProtocolFee,
+            currency,
+            applicationId,
+        });
+    }
+    /**
+     * Forward tokens for protocol fee payment only
+     */
+    async function sponsorProtocolFee(amount, userAddress, applicationId, currency = "USDC") {
+        assertSigner$1(signer);
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: TRANSFER_TYPES.SponsorProtocolFee,
+            currency,
+            applicationId,
+        });
+    }
+    /**
+     * Forward USDC to mint GCTL and stake to a region
+     */
+    async function mintGCTLAndStake(amount, userAddress, regionId, currency = "USDC") {
+        assertSigner$1(signer);
+        // GCTL minting only supports USDC and USDG
+        if (currency === "GLW") {
+            throw new Error("GCTL minting is not supported with GLW payment. Use USDC or USDG.");
+        }
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: TRANSFER_TYPES.MintGCTLAndStake,
+            currency,
+            regionId,
+        });
+    }
+    /**
+     * Forward USDC to mint GCTL (existing functionality, keeping for compatibility)
+     */
+    async function mintGCTL(amount, userAddress, currency = "USDC") {
+        assertSigner$1(signer);
+        // GCTL minting only supports USDC and USDG
+        if (currency === "GLW") {
+            throw new Error("GCTL minting is not supported with GLW payment. Use USDC or USDG.");
+        }
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: TRANSFER_TYPES.MintGCTL,
+            currency,
+        });
+    }
+    /**
+     * Forward tokens to pay audit fees (USDC only, calls forward())
+     */
+    async function payAuditFees(amount, userAddress, applicationId) {
+        assertSigner$1(signer);
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: TRANSFER_TYPES.PayAuditFees,
+            currency: "USDC",
+            applicationId,
+        });
+    }
+    /**
+     * Forward tokens to buy a solar farm
+     */
+    async function buySolarFarm(amount, userAddress, farmId, currency = "USDC") {
+        assertSigner$1(signer);
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: TRANSFER_TYPES.BuySolarFarm,
+            currency,
+            farmId,
+        });
+    }
+    /**
+     * Forward tokens to commit to a Kickstarter (USDC or USDG only)
+     */
+    async function commitKickstarter(amount, userAddress, kickstarterId, currency = "USDC") {
+        assertSigner$1(signer);
+        if (currency === "GLW") {
+            throw new Error("CommitKickstarter supports only USDC or USDG");
+        }
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: TRANSFER_TYPES.CommitKickstarter,
+            currency,
+            kickstarterId,
+        });
+    }
+    /**
+     * Estimate gas for forwarding with type-specific handling
+     * @param params Forward parameters
+     * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
+     */
+    async function estimateGasForForward(params, ethPriceInUSD) {
+        assertSigner$1(signer);
+        try {
+            const forwarderContract = getForwarderContract();
+            if (!forwarderContract)
+                throw new Error(exports.ForwarderError.CONTRACT_NOT_AVAILABLE);
+            const { amount, currency = "USDC" } = params;
+            const isAuditFees = params.type === TRANSFER_TYPES.PayAuditFees;
+            if (isAuditFees && currency !== "USDC") {
+                throw new Error("PayAuditFees only supports USDC");
+            }
+            // Construct the appropriate message for this forward type
+            const message = constructForwardMessage(params);
+            // Determine sendToCounterfactualWallet based on currency
+            const sendToCounterfactualWallet = currency === "GLW" || currency === "USDG";
+            // Get token address
+            let tokenAddress;
+            switch (currency) {
+                case "USDC":
+                    tokenAddress = ADDRESSES.USDC;
+                    break;
+                case "USDG":
+                    tokenAddress = ADDRESSES.USDG;
+                    break;
+                case "GLW":
+                    tokenAddress = ADDRESSES.GLW;
+                    break;
+                default:
+                    throw new Error(`Unsupported currency for gas estimation: ${currency}`);
+            }
+            const feeData = await signer.provider?.getFeeData();
+            const gasPrice = feeData?.gasPrice ?? feeData?.maxFeePerGas ?? 0n;
+            if (gasPrice === 0n) {
+                throw new Error("Could not fetch gas price to estimate cost.");
+            }
+            const estimatedGas = !isAuditFees && currency === "USDC"
+                ? await forwarderContract
+                    .getFunction("swapUSDCAndForwardUSDG")
+                    .estimateGas(amount, ADDRESSES.FOUNDATION_WALLET, sendToCounterfactualWallet, message)
+                : await forwarderContract
+                    .getFunction("forward")
+                    .estimateGas(tokenAddress, isAuditFees
+                    ? ADDRESSES.AUDIT_FEE_WALLET
+                    : ADDRESSES.FOUNDATION_WALLET, amount, sendToCounterfactualWallet, message);
+            const estimatedCost = estimatedGas * gasPrice;
+            if (ethPriceInUSD) {
+                const estimatedCostInEth = viem.formatEther(estimatedCost);
+                const estimatedCostInUSD = (parseFloat(estimatedCostInEth) * ethPriceInUSD).toFixed(2);
+                return estimatedCostInUSD;
+            }
+            else {
+                throw new Error("Could not fetch the ETH price to calculate cost in USD.");
+            }
+        }
+        catch (error) {
+            throw new Error(parseEthersError$1(error));
+        }
+    }
+    /**
+     * Mint test USDC (only works on testnets with mintable USDC contracts)
+     * @param amount Amount of USDC to mint (BigNumber, 6 decimals)
+     * @param recipient Address to mint USDC to
+     */
+    async function mintTestUSDC(amount, recipient) {
+        assertSigner$1(signer);
+        if (CHAIN_ID !== 11155111) {
+            throw new Error("Minting test USDC is only supported on Sepolia");
+        }
+        try {
+            const usdcContract = getTokenContract("USDC"); // Use getTokenContract for consistency
+            if (!usdcContract)
+                throw new Error(exports.ForwarderError.CONTRACT_NOT_AVAILABLE);
+            setIsProcessing(true);
+            // Try to call mint function (common for test tokens)
+            const tx = await usdcContract.mint(recipient, amount);
+            await tx.wait();
+            return tx.hash;
+        }
+        catch (error) {
+            // If mint function doesn't exist or fails, provide helpful error
+            const errorMessage = parseEthersError$1(error);
+            if (errorMessage.includes("mint")) {
+                throw new Error("This USDC contract doesn't support minting");
+            }
+            throw new Error(errorMessage);
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }
+    return {
+        // New methods for different forward types
+        forwardTokens,
+        payProtocolFeeAndMintGCTLAndStake,
+        sponsorProtocolFeeAndMintGCTLAndStake,
+        sponsorProtocolFee,
+        payProtocolFee,
+        mintGCTLAndStake,
+        mintGCTL,
+        buySolarFarm,
+        commitKickstarter,
+        payAuditFees,
+        // Token operations
+        approveToken,
+        checkTokenAllowance,
+        checkTokenBalance,
+        // Utility methods
+        estimateGasForForward,
+        mintTestUSDC,
+        constructForwardMessage,
+        // State
+        get isProcessing() {
+            return isProcessing;
+        },
+        addresses: ADDRESSES,
+        // Signer availability
+        isSignerAvailable: !!signer,
+    };
+}
+
+const OFFCHAIN_FRACTIONS_ABI = [
+    {
+        inputs: [
+            {
+                internalType: "contract CounterfactualHolderFactory",
+                name: "_counterfactualHolderFactory",
+                type: "address",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    {
+        inputs: [{ internalType: "address", name: "target", type: "address" }],
+        name: "AddressEmptyCode",
+        type: "error",
+    },
+    {
+        inputs: [{ internalType: "address", name: "account", type: "address" }],
+        name: "AddressInsufficientBalance",
+        type: "error",
+    },
+    { inputs: [], name: "AlreadyClaimed", type: "error" },
+    { inputs: [], name: "AlreadyClosed", type: "error" },
+    { inputs: [], name: "AlreadyExists", type: "error" },
+    { inputs: [], name: "AlreadySent", type: "error" },
+    {
+        inputs: [],
+        name: "CannotClaimPayoutWhenRoundNotFullyFilled",
+        type: "error",
+    },
+    { inputs: [], name: "CannotClaimRefundWhenNotExpired", type: "error" },
+    { inputs: [], name: "CannotClaimRefundWhenRoundFullyFilled", type: "error" },
+    { inputs: [], name: "CannotCloseAFullRound", type: "error" },
+    { inputs: [], name: "CannotHaveZeroTotalSteps", type: "error" },
+    { inputs: [], name: "Expired", type: "error" },
+    { inputs: [], name: "FailedInnerCall", type: "error" },
+    { inputs: [], name: "InsufficientSharesAvailable", type: "error" },
+    { inputs: [], name: "InvalidToAddress", type: "error" },
+    { inputs: [], name: "InvalidToken", type: "error" },
+    { inputs: [], name: "MinSharesCannotBeGreaterThanTotalSteps", type: "error" },
+    { inputs: [], name: "NoStepsPurchased", type: "error" },
+    { inputs: [], name: "NotAllOrNothing", type: "error" },
+    { inputs: [], name: "NotFractionsOwner", type: "error" },
+    { inputs: [], name: "RecipientCannotBeSelf", type: "error" },
+    { inputs: [], name: "ReentrancyGuardReentrantCall", type: "error" },
+    {
+        inputs: [{ internalType: "address", name: "token", type: "address" }],
+        name: "SafeERC20FailedOperation",
+        type: "error",
+    },
+    { inputs: [], name: "StepMustBeGreaterThanZero", type: "error" },
+    { inputs: [], name: "TaxTokenNotSupported", type: "error" },
+    { inputs: [], name: "TotalRaisedOverflow", type: "error" },
+    { inputs: [], name: "ZeroSteps", type: "error" },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "bytes32", name: "id", type: "bytes32" },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "token",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+        ],
+        name: "FractionClosed",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "bytes32", name: "id", type: "bytes32" },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "token",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "step",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "totalSteps",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint48",
+                name: "expiration",
+                type: "uint48",
+            },
+            { indexed: false, internalType: "address", name: "to", type: "address" },
+            {
+                indexed: false,
+                internalType: "bool",
+                name: "useCounterfactualAddress",
+                type: "bool",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "minSharesToRaise",
+                type: "uint256",
+            },
+        ],
+        name: "FractionCreated",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "bytes32", name: "id", type: "bytes32" },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "creator",
+                type: "address",
+            },
+            { indexed: true, internalType: "address", name: "user", type: "address" },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "amount",
+                type: "uint256",
+            },
+        ],
+        name: "FractionRefunded",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "bytes32", name: "id", type: "bytes32" },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "creator",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "buyer",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "step",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "amount",
+                type: "uint256",
+            },
+        ],
+        name: "FractionSold",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "bytes32", name: "id", type: "bytes32" },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "creator",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "minShares",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "newTotalSharesSold",
+                type: "uint256",
+            },
+        ],
+        name: "MinSharesReached",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "bytes32", name: "id", type: "bytes32" },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "creator",
+                type: "address",
+            },
+        ],
+        name: "RoundFilled",
+        type: "event",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "creator", type: "address" },
+            { internalType: "bytes32", name: "id", type: "bytes32" },
+            { internalType: "uint256", name: "stepsToBuy", type: "uint256" },
+            { internalType: "uint256", name: "minStepsToBuy", type: "uint256" },
+        ],
+        name: "buyFractions",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "creator", type: "address" },
+            { internalType: "bytes32", name: "id", type: "bytes32" },
+        ],
+        name: "claimRefund",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "bytes32", name: "id", type: "bytes32" }],
+        name: "closeFraction",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "bytes32", name: "id", type: "bytes32" },
+            { internalType: "address", name: "token", type: "address" },
+            { internalType: "uint256", name: "step", type: "uint256" },
+            { internalType: "uint256", name: "totalSteps", type: "uint256" },
+            { internalType: "uint48", name: "expiration", type: "uint48" },
+            { internalType: "address", name: "to", type: "address" },
+            { internalType: "bool", name: "useCounterfactualAddress", type: "bool" },
+            { internalType: "uint256", name: "minSharesToRaise", type: "uint256" },
+        ],
+        name: "createFraction",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "creator", type: "address" },
+            { internalType: "bytes32", name: "id", type: "bytes32" },
+        ],
+        name: "getFraction",
+        outputs: [
+            {
+                components: [
+                    { internalType: "address", name: "token", type: "address" },
+                    { internalType: "uint48", name: "expiration", type: "uint48" },
+                    { internalType: "bool", name: "manuallyClosed", type: "bool" },
+                    {
+                        internalType: "uint256",
+                        name: "minSharesToRaise",
+                        type: "uint256",
+                    },
+                    {
+                        internalType: "bool",
+                        name: "useCounterfactualAddress",
+                        type: "bool",
+                    },
+                    {
+                        internalType: "bool",
+                        name: "claimedFromMinSharesToRaise",
+                        type: "bool",
+                    },
+                    { internalType: "address", name: "owner", type: "address" },
+                    { internalType: "uint256", name: "step", type: "uint256" },
+                    { internalType: "address", name: "to", type: "address" },
+                    { internalType: "uint256", name: "soldSteps", type: "uint256" },
+                    { internalType: "uint256", name: "totalSteps", type: "uint256" },
+                ],
+                internalType: "struct OffchainFractions.FractionData",
+                name: "",
+                type: "tuple",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "i_CFHFactory",
+        outputs: [
+            {
+                internalType: "contract CounterfactualHolderFactory",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "user", type: "address" },
+            { internalType: "address", name: "creator", type: "address" },
+            { internalType: "bytes32", name: "id", type: "bytes32" },
+        ],
+        name: "stepsPurchased",
+        outputs: [
+            { internalType: "uint256", name: "stepsPurchased", type: "uint256" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+
+exports.OffchainFractionsError = void 0;
+(function (OffchainFractionsError) {
+    OffchainFractionsError["CONTRACT_NOT_AVAILABLE"] = "Contract not available";
+    OffchainFractionsError["SIGNER_NOT_AVAILABLE"] = "Signer not available";
+    OffchainFractionsError["UNKNOWN_ERROR"] = "Unknown error";
+    OffchainFractionsError["INVALID_PARAMETERS"] = "Invalid parameters";
+    OffchainFractionsError["FRACTION_NOT_FOUND"] = "Fraction not found";
+    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) {
+    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;
+        }
+        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) {
+        throw new Error(exports.OffchainFractionsError.SIGNER_NOT_AVAILABLE);
+    }
+}
+function useOffchainFractions(signer, CHAIN_ID) {
+    // Use dynamic addresses based on chain configuration
+    const ADDRESSES = getAddresses(CHAIN_ID);
+    // Framework-agnostic processing flag
+    let isProcessing = false;
+    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);
+    }
+    /**
+     * Check current token allowance for the offchain fractions contract
+     * @param owner The wallet address to check allowance for
+     * @param tokenAddress The token contract address
+     */
+    async function checkTokenAllowance(owner, tokenAddress) {
+        assertSigner(signer);
+        try {
+            const tokenContract = getTokenContract(tokenAddress);
+            if (!tokenContract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            const allowance = await tokenContract.allowance(owner, ADDRESSES.OFFCHAIN_FRACTIONS);
+            return allowance;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * Check user's token balance
+     * @param owner The wallet address to check balance for
+     * @param tokenAddress The token contract address
+     */
+    async function checkTokenBalance(owner, tokenAddress) {
+        assertSigner(signer);
+        try {
+            const tokenContract = getTokenContract(tokenAddress);
+            if (!tokenContract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            const balance = await tokenContract.balanceOf(owner);
+            return balance;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * Approve tokens for the offchain fractions contract
+     * @param tokenAddress The token contract address
+     * @param amount Amount to approve (BigNumber)
+     */
+    async function approveToken(tokenAddress, amount) {
+        assertSigner(signer);
+        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();
+            return true;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }
+    /**
+     * Create a new fractional token sale
+     * @param params Parameters for creating the fraction
+     */
+    async function createFraction(params) {
+        assertSigner(signer);
+        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, } = params;
+            // Validate parameters
+            if (!id || !token || !to) {
+                throw new Error(exports.OffchainFractionsError.INVALID_PARAMETERS);
+            }
+            if (step === 0n || totalSteps === 0n) {
+                throw new Error("Step and totalSteps must be greater than zero");
+            }
+            if (minSharesToRaise > totalSteps) {
+                throw new Error("minSharesToRaise cannot be greater than totalSteps");
+            }
+            // Run a static call first to surface any revert reason
+            try {
+                await contract
+                    .getFunction("createFraction")
+                    .staticCall(id, token, step, totalSteps, expiration, to, useCounterfactualAddress, minSharesToRaise);
+            }
+            catch (staticError) {
+                throw new Error(parseEthersError(staticError));
+            }
+            // Execute the transaction
+            const tx = await contract.getFunction("createFraction")(id, token, step, totalSteps, expiration, to, useCounterfactualAddress, minSharesToRaise);
+            await tx.wait();
+            return tx.hash;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }
+    /**
+     * Buy fractions in an existing sale
+     * @param params Parameters for buying fractions
+     */
+    async function buyFractions(params) {
+        assertSigner(signer);
+        try {
+            const contract = getOffchainFractionsContract();
+            if (!contract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            setIsProcessing(true);
+            const { creator, id, stepsToBuy, minStepsToBuy } = params;
+            // Validate parameters
+            if (!creator || !id) {
+                throw new Error(exports.OffchainFractionsError.INVALID_PARAMETERS);
+            }
+            if (stepsToBuy === 0n) {
+                throw new Error("stepsToBuy must be greater than zero");
+            }
+            // Get fraction data to calculate required amount
+            const fractionData = await getFraction(creator, id);
+            const requiredAmount = stepsToBuy * fractionData.step;
+            const owner = await signer.getAddress();
+            // Check token balance
+            const balance = await checkTokenBalance(owner, fractionData.token);
+            if (balance < requiredAmount) {
+                throw new Error(exports.OffchainFractionsError.INSUFFICIENT_BALANCE);
+            }
+            // 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();
+            }
+            // Run a static call first to surface any revert reason
+            try {
+                await contract
+                    .getFunction("buyFractions")
+                    .staticCall(creator, id, stepsToBuy, minStepsToBuy, {
+                    from: owner,
+                });
+            }
+            catch (staticError) {
+                throw new Error(parseEthersError(staticError));
+            }
+            // Execute the transaction
+            const tx = await contract.getFunction("buyFractions")(creator, id, stepsToBuy, minStepsToBuy);
+            await tx.wait();
+            return tx.hash;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }
+    /**
+     * Claim refund from an unfilled sale
+     * @param creator The address that created the fraction sale
+     * @param id The unique identifier of the fraction sale
+     */
+    async function claimRefund(creator, id) {
+        assertSigner(signer);
+        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();
+            // Check if user has steps purchased
+            const userSteps = await getStepsPurchased(owner, creator, id);
+            if (userSteps === 0n) {
+                throw new Error("No steps purchased for this fraction");
+            }
+            // Run a static call first to surface any revert reason
+            try {
+                await contract.getFunction("claimRefund").staticCall(creator, id, {
+                    from: owner,
+                });
+            }
+            catch (staticError) {
+                throw new Error(parseEthersError(staticError));
+            }
+            // Execute the transaction
+            const tx = await contract.getFunction("claimRefund")(creator, id);
+            await tx.wait();
+            return tx.hash;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }
+    /**
+     * Close a fraction sale manually (only by owner)
+     * @param id The unique identifier of the fraction sale to close
+     */
+    async function closeFraction(id) {
+        assertSigner(signer);
+        try {
+            const contract = getOffchainFractionsContract();
+            if (!contract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            setIsProcessing(true);
+            // Validate parameters
+            if (!id) {
+                throw new Error(exports.OffchainFractionsError.INVALID_PARAMETERS);
+            }
+            const owner = await signer.getAddress();
+            // Run a static call first to surface any revert reason
+            try {
+                await contract.getFunction("closeFraction").staticCall(id, {
+                    from: owner,
+                });
+            }
             catch (staticError) {
                 throw new Error(parseEthersError(staticError));
             }
-            // Execute the forward transaction
-            let tx;
-            if (!isAuditFees && currency === "USDC") {
-                tx = await forwarderContract.getFunction("swapUSDCAndForwardUSDG")(amount, ADDRESSES.FOUNDATION_WALLET, sendToCounterfactualWallet, message);
-            }
-            else {
-                tx = await forwarderContract.getFunction("forward")(tokenAddress, isAuditFees
-                    ? ADDRESSES.AUDIT_FEE_WALLET
-                    : ADDRESSES.FOUNDATION_WALLET, amount, sendToCounterfactualWallet, message);
-            }
+            // Execute the transaction
+            const tx = await contract.getFunction("closeFraction")(id);
             await tx.wait();
             return tx.hash;
         }
-        catch (txError) {
-            throw new Error(parseEthersError(txError));
+        catch (error) {
+            throw new Error(parseEthersError(error));
         }
         finally {
             setIsProcessing(false);
         }
     }
     /**
-     * Forward tokens for protocol fee payment and GCTL minting with staking
+     * Get fraction data for a specific creator and ID
+     * @param creator The address that created the fraction sale
+     * @param id The unique identifier of the fraction sale
      */
-    async function payProtocolFeeAndMintGCTLAndStake(amount, userAddress, applicationId, regionId, currency = "USDC") {
+    async function getFraction(creator, id) {
         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.");
+        try {
+            const contract = getOffchainFractionsContract();
+            if (!contract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            const result = await contract.getFraction(creator, id);
+            return {
+                token: result.token,
+                expiration: Number(result.expiration),
+                manuallyClosed: result.manuallyClosed,
+                minSharesToRaise: result.minSharesToRaise,
+                useCounterfactualAddress: result.useCounterfactualAddress,
+                claimedFromMinSharesToRaise: result.claimedFromMinSharesToRaise,
+                owner: result.owner,
+                step: result.step,
+                to: result.to,
+                soldSteps: result.soldSteps,
+                totalSteps: result.totalSteps,
+            };
         }
-        return forwardTokens({
-            amount,
-            userAddress,
-            type: TRANSFER_TYPES.PayProtocolFeeAndMintGCTLAndStake,
-            currency,
-            applicationId,
-            regionId,
-        });
-    }
-    /**
-     * Forward tokens for protocol fee payment and GCTL minting with staking
-     */
-    async function sponsorProtocolFeeAndMintGCTLAndStake(amount, userAddress, applicationId, currency = "USDC") {
-        assertSigner(signer);
-        if (currency === "GLW") {
-            throw new Error("GCTL minting is not supported with GLW payment. Use USDC or USDG.");
+        catch (error) {
+            throw new Error(parseEthersError(error));
         }
-        return forwardTokens({
-            amount,
-            userAddress,
-            type: TRANSFER_TYPES.SponsorProtocolFeeAndMintGCTLAndStake,
-            currency,
-            applicationId,
-        });
-    }
-    /**
-     * Forward tokens for protocol fee payment only
-     */
-    async function payProtocolFee(amount, userAddress, applicationId, currency = "USDC") {
-        assertSigner(signer);
-        return forwardTokens({
-            amount,
-            userAddress,
-            type: TRANSFER_TYPES.PayProtocolFee,
-            currency,
-            applicationId,
-        });
     }
     /**
-     * Forward tokens for protocol fee payment only
+     * Get the number of steps purchased by a user for a specific fraction
+     * @param user The user address
+     * @param creator The address that created the fraction sale
+     * @param id The unique identifier of the fraction sale
      */
-    async function sponsorProtocolFee(amount, userAddress, applicationId, currency = "USDC") {
+    async function getStepsPurchased(user, creator, id) {
         assertSigner(signer);
-        return forwardTokens({
-            amount,
-            userAddress,
-            type: TRANSFER_TYPES.SponsorProtocolFee,
-            currency,
-            applicationId,
-        });
+        try {
+            const contract = getOffchainFractionsContract();
+            if (!contract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            const result = await contract.stepsPurchased(user, creator, id);
+            return result;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
     }
     /**
-     * Forward USDC to mint GCTL and stake to a region
+     * Check if a fraction sale is expired
+     * @param creator The address that created the fraction sale
+     * @param id The unique identifier of the fraction sale
      */
-    async function mintGCTLAndStake(amount, userAddress, regionId, currency = "USDC") {
-        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.");
+    async function isFractionExpired(creator, id) {
+        try {
+            const fraction = await getFraction(creator, id);
+            return Date.now() / 1000 > fraction.expiration;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
         }
-        return forwardTokens({
-            amount,
-            userAddress,
-            type: TRANSFER_TYPES.MintGCTLAndStake,
-            currency,
-            regionId,
-        });
     }
     /**
-     * Forward USDC to mint GCTL (existing functionality, keeping for compatibility)
+     * Check if a fraction sale has reached its minimum shares threshold
+     * @param creator The address that created the fraction sale
+     * @param id The unique identifier of the fraction sale
      */
-    async function mintGCTL(amount, userAddress, currency = "USDC") {
-        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.");
+    async function hasReachedMinimumShares(creator, id) {
+        try {
+            const fraction = await getFraction(creator, id);
+            return fraction.soldSteps >= fraction.minSharesToRaise;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
         }
-        return forwardTokens({
-            amount,
-            userAddress,
-            type: TRANSFER_TYPES.MintGCTL,
-            currency,
-        });
     }
     /**
-     * Forward tokens to pay audit fees (USDC only, calls forward())
+     * Check if a fraction sale is completely filled
+     * @param creator The address that created the fraction sale
+     * @param id The unique identifier of the fraction sale
      */
-    async function payAuditFees(amount, userAddress, applicationId) {
-        assertSigner(signer);
-        return forwardTokens({
-            amount,
-            userAddress,
-            type: TRANSFER_TYPES.PayAuditFees,
-            currency: "USDC",
-            applicationId,
-        });
+    async function isFractionCompletelyFilled(creator, id) {
+        try {
+            const fraction = await getFraction(creator, id);
+            return fraction.soldSteps >= fraction.totalSteps;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
     }
     /**
-     * Forward tokens to buy a solar farm
+     * Calculate the total amount raised for a fraction
+     * @param creator The address that created the fraction sale
+     * @param id The unique identifier of the fraction sale
      */
-    async function buySolarFarm(amount, userAddress, farmId, currency = "USDC") {
-        assertSigner(signer);
-        return forwardTokens({
-            amount,
-            userAddress,
-            type: TRANSFER_TYPES.BuySolarFarm,
-            currency,
-            farmId,
-        });
+    async function getTotalAmountRaised(creator, id) {
+        try {
+            const fraction = await getFraction(creator, id);
+            return fraction.soldSteps * fraction.step;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
     }
     /**
-     * Forward tokens to commit to a Kickstarter (USDC or USDG only)
+     * Calculate the remaining steps available for purchase
+     * @param creator The address that created the fraction sale
+     * @param id The unique identifier of the fraction sale
      */
-    async function commitKickstarter(amount, userAddress, kickstarterId, currency = "USDC") {
-        assertSigner(signer);
-        if (currency === "GLW") {
-            throw new Error("CommitKickstarter supports only USDC or USDG");
+    async function getRemainingSteps(creator, id) {
+        try {
+            const fraction = await getFraction(creator, id);
+            return fraction.totalSteps - fraction.soldSteps;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
         }
-        return forwardTokens({
-            amount,
-            userAddress,
-            type: TRANSFER_TYPES.CommitKickstarter,
-            currency,
-            kickstarterId,
-        });
     }
     /**
-     * Estimate gas for forwarding with type-specific handling
-     * @param params Forward parameters
+     * Estimate gas for creating a fraction
+     * @param params Parameters for creating the fraction
      * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
      */
-    async function estimateGasForForward(params, ethPriceInUSD) {
+    async function estimateGasForCreateFraction(params, ethPriceInUSD) {
         assertSigner(signer);
         try {
-            const forwarderContract = getForwarderContract();
-            if (!forwarderContract)
-                throw new Error(exports.ForwarderError.CONTRACT_NOT_AVAILABLE);
-            const { amount, currency = "USDC" } = params;
-            const isAuditFees = params.type === TRANSFER_TYPES.PayAuditFees;
-            if (isAuditFees && currency !== "USDC") {
-                throw new Error("PayAuditFees only supports USDC");
-            }
-            // Construct the appropriate message for this forward type
-            const message = constructForwardMessage(params);
-            // Determine sendToCounterfactualWallet based on currency
-            const sendToCounterfactualWallet = currency === "GLW" || currency === "USDG";
-            // Get token address
-            let tokenAddress;
-            switch (currency) {
-                case "USDC":
-                    tokenAddress = ADDRESSES.USDC;
-                    break;
-                case "USDG":
-                    tokenAddress = ADDRESSES.USDG;
-                    break;
-                case "GLW":
-                    tokenAddress = ADDRESSES.GLW;
-                    break;
-                default:
-                    throw new Error(`Unsupported currency for gas estimation: ${currency}`);
-            }
+            const contract = getOffchainFractionsContract();
+            if (!contract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            const { id, token, step, totalSteps, expiration, to, useCounterfactualAddress, minSharesToRaise, } = params;
             const feeData = await signer.provider?.getFeeData();
             const gasPrice = feeData?.gasPrice ?? feeData?.maxFeePerGas ?? 0n;
             if (gasPrice === 0n) {
                 throw new Error("Could not fetch gas price to estimate cost.");
             }
-            const estimatedGas = !isAuditFees && currency === "USDC"
-                ? await forwarderContract
-                    .getFunction("swapUSDCAndForwardUSDG")
-                    .estimateGas(amount, ADDRESSES.FOUNDATION_WALLET, sendToCounterfactualWallet, message)
-                : await forwarderContract
-                    .getFunction("forward")
-                    .estimateGas(tokenAddress, isAuditFees
-                    ? ADDRESSES.AUDIT_FEE_WALLET
-                    : ADDRESSES.FOUNDATION_WALLET, amount, sendToCounterfactualWallet, message);
+            const estimatedGas = await contract
+                .getFunction("createFraction")
+                .estimateGas(id, token, step, totalSteps, expiration, to, useCounterfactualAddress, minSharesToRaise);
             const estimatedCost = estimatedGas * gasPrice;
             if (ethPriceInUSD) {
                 const estimatedCostInEth = viem.formatEther(estimatedCost);
@@ -756,57 +1611,61 @@ function useForwarder(signer, CHAIN_ID) {
         }
     }
     /**
-     * Mint test USDC (only works on testnets with mintable USDC contracts)
-     * @param amount Amount of USDC to mint (BigNumber, 6 decimals)
-     * @param recipient Address to mint USDC to
+     * Estimate gas for buying fractions
+     * @param params Parameters for buying fractions
+     * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
      */
-    async function mintTestUSDC(amount, recipient) {
+    async function estimateGasForBuyFractions(params, ethPriceInUSD) {
         assertSigner(signer);
-        if (CHAIN_ID !== 11155111) {
-            throw new Error("Minting test USDC is only supported on Sepolia");
-        }
         try {
-            const usdcContract = getTokenContract("USDC"); // Use getTokenContract for consistency
-            if (!usdcContract)
-                throw new Error(exports.ForwarderError.CONTRACT_NOT_AVAILABLE);
-            setIsProcessing(true);
-            // Try to call mint function (common for test tokens)
-            const tx = await usdcContract.mint(recipient, amount);
-            await tx.wait();
-            return tx.hash;
-        }
-        catch (error) {
-            // If mint function doesn't exist or fails, provide helpful error
-            const errorMessage = parseEthersError(error);
-            if (errorMessage.includes("mint")) {
-                throw new Error("This USDC contract doesn't support minting");
+            const contract = getOffchainFractionsContract();
+            if (!contract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            const { creator, id, stepsToBuy, minStepsToBuy } = params;
+            const feeData = await signer.provider?.getFeeData();
+            const gasPrice = feeData?.gasPrice ?? feeData?.maxFeePerGas ?? 0n;
+            if (gasPrice === 0n) {
+                throw new Error("Could not fetch gas price to estimate cost.");
+            }
+            const estimatedGas = await contract
+                .getFunction("buyFractions")
+                .estimateGas(creator, id, stepsToBuy, minStepsToBuy);
+            const estimatedCost = estimatedGas * gasPrice;
+            if (ethPriceInUSD) {
+                const estimatedCostInEth = viem.formatEther(estimatedCost);
+                const estimatedCostInUSD = (parseFloat(estimatedCostInEth) * ethPriceInUSD).toFixed(2);
+                return estimatedCostInUSD;
+            }
+            else {
+                throw new Error("Could not fetch the ETH price to calculate cost in USD.");
             }
-            throw new Error(errorMessage);
         }
-        finally {
-            setIsProcessing(false);
+        catch (error) {
+            throw new Error(parseEthersError(error));
         }
     }
     return {
-        // New methods for different forward types
-        forwardTokens,
-        payProtocolFeeAndMintGCTLAndStake,
-        sponsorProtocolFeeAndMintGCTLAndStake,
-        sponsorProtocolFee,
-        payProtocolFee,
-        mintGCTLAndStake,
-        mintGCTL,
-        buySolarFarm,
-        commitKickstarter,
-        payAuditFees,
+        // Core contract functions
+        createFraction,
+        buyFractions,
+        claimRefund,
+        closeFraction,
+        // View functions
+        getFraction,
+        getStepsPurchased,
         // Token operations
         approveToken,
         checkTokenAllowance,
         checkTokenBalance,
-        // Utility methods
-        estimateGasForForward,
-        mintTestUSDC,
-        constructForwardMessage,
+        // Utility functions
+        isFractionExpired,
+        hasReachedMinimumShares,
+        isFractionCompletelyFilled,
+        getTotalAmountRaised,
+        getRemainingSteps,
+        // Gas estimation
+        estimateGasForCreateFraction,
+        estimateGasForBuyFractions,
         // State
         get isProcessing() {
             return isProcessing;
@@ -2159,8 +3018,31 @@ function FarmsRouter(baseUrl) {
             throw new Error(parseApiError(error));
         }
     };
+    const estimateRewardScore = async (params) => {
+        try {
+            // First try to get the success response
+            const data = await request("/farms/estimate-reward-score", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(params),
+            });
+            // Check if it's an error response
+            if ("error" in data) {
+                throw new Error(data.error);
+            }
+            // At this point, TypeScript knows it's EstimateRewardScoreApiResponse
+            // All fields are required in the success response based on the API spec
+            return data;
+        }
+        catch (error) {
+            throw new Error(parseApiError(error));
+        }
+    };
     return {
         fetchSponsoredFarms,
+        estimateRewardScore,
     };
 }
 
@@ -2185,4 +3067,5 @@ exports.getAddresses = getAddresses;
 exports.regionMetadata = regionMetadata;
 exports.usStates = usStates;
 exports.useForwarder = useForwarder;
-//# sourceMappingURL=farms-router-DCCy-acA.js.map
+exports.useOffchainFractions = useOffchainFractions;
+//# sourceMappingURL=farms-router-CDsqKkP6.js.map