@glowlabs-org/utils 0.2.95 → 0.2.96

package/dist/cjs/{farms-router-DCCy-acA.js → farms-router-DCsg5FYX.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
@@ -535,7 +539,7 @@ function useForwarder(signer, CHAIN_ID) {
                 }
             }
             catch (staticError) {
-                throw new Error(parseEthersError(staticError));
+                throw new Error(parseEthersError$1(staticError));
             }
             // Execute the forward transaction
             let tx;
@@ -551,7 +555,7 @@ function useForwarder(signer, CHAIN_ID) {
             return tx.hash;
         }
         catch (txError) {
-            throw new Error(parseEthersError(txError));
+            throw new Error(parseEthersError$1(txError));
         }
         finally {
             setIsProcessing(false);
@@ -561,7 +565,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(signer);
+        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.");
@@ -579,7 +583,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(signer);
+        assertSigner$1(signer);
         if (currency === "GLW") {
             throw new Error("GCTL minting is not supported with GLW payment. Use USDC or USDG.");
         }
@@ -595,7 +599,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward tokens for protocol fee payment only
      */
     async function payProtocolFee(amount, userAddress, applicationId, currency = "USDC") {
-        assertSigner(signer);
+        assertSigner$1(signer);
         return forwardTokens({
             amount,
             userAddress,
@@ -608,7 +612,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward tokens for protocol fee payment only
      */
     async function sponsorProtocolFee(amount, userAddress, applicationId, currency = "USDC") {
-        assertSigner(signer);
+        assertSigner$1(signer);
         return forwardTokens({
             amount,
             userAddress,
@@ -621,7 +625,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(signer);
+        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.");
@@ -638,7 +642,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward USDC to mint GCTL (existing functionality, keeping for compatibility)
      */
     async function mintGCTL(amount, userAddress, currency = "USDC") {
-        assertSigner(signer);
+        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.");
@@ -654,7 +658,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward tokens to pay audit fees (USDC only, calls forward())
      */
     async function payAuditFees(amount, userAddress, applicationId) {
-        assertSigner(signer);
+        assertSigner$1(signer);
         return forwardTokens({
             amount,
             userAddress,
@@ -667,7 +671,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward tokens to buy a solar farm
      */
     async function buySolarFarm(amount, userAddress, farmId, currency = "USDC") {
-        assertSigner(signer);
+        assertSigner$1(signer);
         return forwardTokens({
             amount,
             userAddress,
@@ -680,7 +684,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(signer);
+        assertSigner$1(signer);
         if (currency === "GLW") {
             throw new Error("CommitKickstarter supports only USDC or USDG");
         }
@@ -698,7 +702,7 @@ function useForwarder(signer, CHAIN_ID) {
      * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
      */
     async function estimateGasForForward(params, ethPriceInUSD) {
-        assertSigner(signer);
+        assertSigner$1(signer);
         try {
             const forwarderContract = getForwarderContract();
             if (!forwarderContract)
@@ -752,7 +756,7 @@ function useForwarder(signer, CHAIN_ID) {
             }
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseEthersError$1(error));
         }
     }
     /**
@@ -761,7 +765,7 @@ function useForwarder(signer, CHAIN_ID) {
      * @param recipient Address to mint USDC to
      */
     async function mintTestUSDC(amount, recipient) {
-        assertSigner(signer);
+        assertSigner$1(signer);
         if (CHAIN_ID !== 11155111) {
             throw new Error("Minting test USDC is only supported on Sepolia");
         }
@@ -777,7 +781,7 @@ function useForwarder(signer, CHAIN_ID) {
         }
         catch (error) {
             // If mint function doesn't exist or fails, provide helpful error
-            const errorMessage = parseEthersError(error);
+            const errorMessage = parseEthersError$1(error);
             if (errorMessage.includes("mint")) {
                 throw new Error("This USDC contract doesn't support minting");
             }
@@ -817,6 +821,861 @@ function useForwarder(signer, CHAIN_ID) {
     };
 }
 
+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 transaction
+            const tx = await contract.getFunction("closeFraction")(id);
+            await tx.wait();
+            return tx.hash;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }
+    /**
+     * 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 getFraction(creator, id) {
+        assertSigner(signer);
+        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,
+            };
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * 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 getStepsPurchased(user, creator, id) {
+        assertSigner(signer);
+        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));
+        }
+    }
+    /**
+     * 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 isFractionExpired(creator, id) {
+        try {
+            const fraction = await getFraction(creator, id);
+            return Date.now() / 1000 > fraction.expiration;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * 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 hasReachedMinimumShares(creator, id) {
+        try {
+            const fraction = await getFraction(creator, id);
+            return fraction.soldSteps >= fraction.minSharesToRaise;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * 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 isFractionCompletelyFilled(creator, id) {
+        try {
+            const fraction = await getFraction(creator, id);
+            return fraction.soldSteps >= fraction.totalSteps;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * 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 getTotalAmountRaised(creator, id) {
+        try {
+            const fraction = await getFraction(creator, id);
+            return fraction.soldSteps * fraction.step;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * 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 getRemainingSteps(creator, id) {
+        try {
+            const fraction = await getFraction(creator, id);
+            return fraction.totalSteps - fraction.soldSteps;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * 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 estimateGasForCreateFraction(params, ethPriceInUSD) {
+        assertSigner(signer);
+        try {
+            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 = await contract
+                .getFunction("createFraction")
+                .estimateGas(id, token, step, totalSteps, expiration, to, useCounterfactualAddress, minSharesToRaise);
+            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(error));
+        }
+    }
+    /**
+     * Estimate gas for buying fractions
+     * @param params Parameters for buying fractions
+     * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
+     */
+    async function estimateGasForBuyFractions(params, ethPriceInUSD) {
+        assertSigner(signer);
+        try {
+            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.");
+            }
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    return {
+        // Core contract functions
+        createFraction,
+        buyFractions,
+        claimRefund,
+        closeFraction,
+        // View functions
+        getFraction,
+        getStepsPurchased,
+        // Token operations
+        approveToken,
+        checkTokenAllowance,
+        checkTokenBalance,
+        // Utility functions
+        isFractionExpired,
+        hasReachedMinimumShares,
+        isFractionCompletelyFilled,
+        getTotalAmountRaised,
+        getRemainingSteps,
+        // Gas estimation
+        estimateGasForCreateFraction,
+        estimateGasForBuyFractions,
+        // State
+        get isProcessing() {
+            return isProcessing;
+        },
+        addresses: ADDRESSES,
+        // Signer availability
+        isSignerAvailable: !!signer,
+    };
+}
+
 // --------------------------------------------------------------------------
 /**
  * Extract a useful error message from an unknown error value.
@@ -2185,4 +3044,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-DCsg5FYX.js.map