@glowlabs-org/utils 0.2.109 → 0.2.110

package/dist/cjs/browser.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var farmsRouter = require('./farms-router-DuVI7Pig.js');
+var farmsRouter = require('./farms-router-DhAOciuN.js');
 var viem = require('viem');
 require('ethers');
 

package/dist/cjs/{farms-router-DuVI7Pig.js → farms-router-DhAOciuN.js}

@@ -850,31 +850,30 @@ const OFFCHAIN_FRACTIONS_ABI = [
         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: "CannotClaimRefundWhenThresholdReached", type: "error" },
+    { inputs: [], name: "CannotCloseWhenThresholdReached", type: "error" },
     { inputs: [], name: "CannotHaveZeroTotalSteps", type: "error" },
+    { inputs: [], name: "ExpirationMustBeInTheFuture", 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: "MinStepsToBuyCannotBeGreaterThanStepsToBuy",
+        type: "error",
+    },
+    { inputs: [], name: "MinStepsToBuyCannotBeZero", type: "error" },
     { inputs: [], name: "NoStepsPurchased", type: "error" },
-    { inputs: [], name: "NotAllOrNothing", type: "error" },
     { inputs: [], name: "NotFractionsCloser", type: "error" },
-    { inputs: [], name: "NotFractionsOwner", type: "error" },
     { inputs: [], name: "RecipientCannotBeSelf", type: "error" },
     { inputs: [], name: "ReentrancyGuardReentrantCall", type: "error" },
+    { inputs: [], name: "RefundOperatorNotApproved", type: "error" },
     {
         inputs: [{ internalType: "address", name: "token", type: "address" }],
         name: "SafeERC20FailedOperation",
@@ -883,6 +882,11 @@ const OFFCHAIN_FRACTIONS_ABI = [
     { inputs: [], name: "StepMustBeGreaterThanZero", type: "error" },
     { inputs: [], name: "TaxTokenNotSupported", type: "error" },
     { inputs: [], name: "TotalRaisedOverflow", type: "error" },
+    {
+        inputs: [],
+        name: "UseCounterfactualAddressForRefundNotAllowedIfAddressIsZero",
+        type: "error",
+    },
     { inputs: [], name: "ZeroSteps", type: "error" },
     {
         anonymous: false,
@@ -972,6 +976,12 @@ const OFFCHAIN_FRACTIONS_ABI = [
                 type: "address",
             },
             { indexed: true, internalType: "address", name: "user", type: "address" },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "refundTo",
+                type: "address",
+            },
             {
                 indexed: false,
                 internalType: "uint256",
@@ -995,6 +1005,12 @@ const OFFCHAIN_FRACTIONS_ABI = [
             {
                 indexed: true,
                 internalType: "address",
+                name: "creditTo",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
                 name: "buyer",
                 type: "address",
             },
@@ -1040,6 +1056,26 @@ const OFFCHAIN_FRACTIONS_ABI = [
         name: "MinSharesReached",
         type: "event",
     },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "address", name: "user", type: "address" },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "refundOperator",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "bool",
+                name: "isApproved",
+                type: "bool",
+            },
+        ],
+        name: "RefundOperatorStatusSet",
+        type: "event",
+    },
     {
         anonymous: false,
         inputs: [
@@ -1054,12 +1090,26 @@ const OFFCHAIN_FRACTIONS_ABI = [
         name: "RoundFilled",
         type: "event",
     },
+    {
+        inputs: [],
+        name: "REFUND_WILDCARD_OPERATOR",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
     {
         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" },
+            { internalType: "address", name: "refundTo", type: "address" },
+            { internalType: "address", name: "creditTo", type: "address" },
+            {
+                internalType: "bool",
+                name: "useCounterfactualAddressForRefund",
+                type: "bool",
+            },
         ],
         name: "buyFractions",
         outputs: [],
@@ -1068,6 +1118,7 @@ const OFFCHAIN_FRACTIONS_ABI = [
     },
     {
         inputs: [
+            { internalType: "address", name: "user", type: "address" },
             { internalType: "address", name: "creator", type: "address" },
             { internalType: "bytes32", name: "id", type: "bytes32" },
         ],
@@ -1130,7 +1181,6 @@ const OFFCHAIN_FRACTIONS_ABI = [
                         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" },
@@ -1145,6 +1195,31 @@ const OFFCHAIN_FRACTIONS_ABI = [
         stateMutability: "view",
         type: "function",
     },
+    {
+        inputs: [
+            { internalType: "address", name: "user", type: "address" },
+            { internalType: "address", name: "creator", type: "address" },
+            { internalType: "bytes32", name: "id", type: "bytes32" },
+        ],
+        name: "getRefundDetails",
+        outputs: [
+            {
+                components: [
+                    { internalType: "address", name: "refundTo", type: "address" },
+                    {
+                        internalType: "bool",
+                        name: "useCounterfactualAddress",
+                        type: "bool",
+                    },
+                ],
+                internalType: "struct OffchainFractions.RefundDetails",
+                name: "",
+                type: "tuple",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
     {
         inputs: [],
         name: "i_CFHFactory",
@@ -1158,6 +1233,48 @@ const OFFCHAIN_FRACTIONS_ABI = [
         stateMutability: "view",
         type: "function",
     },
+    {
+        inputs: [
+            { internalType: "address", name: "user", type: "address" },
+            { internalType: "address", name: "refundOperator", type: "address" },
+        ],
+        name: "isRefundOperatorApproved",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "user", type: "address" },
+            { internalType: "address", name: "refundOperator", type: "address" },
+        ],
+        name: "refundApprovals",
+        outputs: [{ internalType: "bool", name: "isApproved", type: "bool" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "creator", type: "address" },
+            { internalType: "bytes32", name: "id", type: "bytes32" },
+            { internalType: "address", name: "refundTo", type: "address" },
+            { internalType: "bool", name: "useCounterfactualAddress", type: "bool" },
+        ],
+        name: "setRefundDetails",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "refundOperator", type: "address" },
+            { internalType: "bool", name: "isApproved", type: "bool" },
+        ],
+        name: "setRefundOperatorStatus",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
     {
         inputs: [
             { internalType: "address", name: "user", type: "address" },
@@ -1349,14 +1466,17 @@ function useOffchainFractions(signer, CHAIN_ID) {
             if (!contract)
                 throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
-            const { creator, id, stepsToBuy, minStepsToBuy } = params;
+            const { creator, id, stepsToBuy, minStepsToBuy, refundTo, creditTo, useCounterfactualAddressForRefund, } = params;
             // Validate parameters
-            if (!creator || !id) {
+            if (!creator || !id || !refundTo || !creditTo) {
                 throw new Error(exports.OffchainFractionsError.INVALID_PARAMETERS);
             }
             if (stepsToBuy === 0n) {
                 throw new Error("stepsToBuy must be greater than zero");
             }
+            if (minStepsToBuy === 0n) {
+                throw new Error("minStepsToBuy must be greater than zero");
+            }
             // Get fraction data to calculate required amount
             const fractionData = await getFraction(creator, id);
             const requiredAmount = stepsToBuy * fractionData.step;
@@ -1377,7 +1497,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             try {
                 await contract
                     .getFunction("buyFractions")
-                    .staticCall(creator, id, stepsToBuy, minStepsToBuy, {
+                    .staticCall(creator, id, stepsToBuy, minStepsToBuy, refundTo, creditTo, useCounterfactualAddressForRefund, {
                     from: owner,
                 });
             }
@@ -1385,7 +1505,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
                 throw new Error(parseEthersError(staticError));
             }
             // Execute the transaction
-            const tx = await contract.getFunction("buyFractions")(creator, id, stepsToBuy, minStepsToBuy);
+            const tx = await contract.getFunction("buyFractions")(creator, id, stepsToBuy, minStepsToBuy, refundTo, creditTo, useCounterfactualAddressForRefund);
             await tx.wait();
             return tx.hash;
         }
@@ -1398,10 +1518,11 @@ function useOffchainFractions(signer, CHAIN_ID) {
     }
     /**
      * Claim refund from an unfilled sale
+     * @param user The user address claiming the refund
      * @param creator The address that created the fraction sale
      * @param id The unique identifier of the fraction sale
      */
-    async function claimRefund(creator, id) {
+    async function claimRefund(user, creator, id) {
         assertSigner(signer);
         try {
             const contract = getOffchainFractionsContract();
@@ -1409,18 +1530,20 @@ function useOffchainFractions(signer, CHAIN_ID) {
                 throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
             // Validate parameters
-            if (!creator || !id) {
+            if (!user || !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);
+            const userSteps = await getStepsPurchased(user, creator, id);
             if (userSteps === 0n) {
                 throw new Error("No steps purchased for this fraction");
             }
             // Run a static call first to surface any revert reason
             try {
-                await contract.getFunction("claimRefund").staticCall(creator, id, {
+                await contract
+                    .getFunction("claimRefund")
+                    .staticCall(user, creator, id, {
                     from: owner,
                 });
             }
@@ -1428,7 +1551,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
                 throw new Error(parseEthersError(staticError));
             }
             // Execute the transaction
-            const tx = await contract.getFunction("claimRefund")(creator, id);
+            const tx = await contract.getFunction("claimRefund")(user, creator, id);
             await tx.wait();
             return tx.hash;
         }
@@ -1496,7 +1619,6 @@ function useOffchainFractions(signer, CHAIN_ID) {
                 minSharesToRaise: result.minSharesToRaise,
                 useCounterfactualAddress: result.useCounterfactualAddress,
                 claimedFromMinSharesToRaise: result.claimedFromMinSharesToRaise,
-                owner: result.owner,
                 step: result.step,
                 to: result.to,
                 soldSteps: result.soldSteps,
@@ -1527,6 +1649,163 @@ function useOffchainFractions(signer, CHAIN_ID) {
             throw new Error(parseEthersError(error));
         }
     }
+    /**
+     * Get the refund wildcard operator address
+     * @returns The wildcard operator address that can perform refunds for any user
+     */
+    async function getRefundWildcardOperator() {
+        assertSigner(signer);
+        try {
+            const contract = getOffchainFractionsContract();
+            if (!contract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            const result = await contract.getFunction("REFUND_WILDCARD_OPERATOR")();
+            return result;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * Get refund details for a user's purchase
+     * @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 getRefundDetails(user, creator, id) {
+        assertSigner(signer);
+        try {
+            const contract = getOffchainFractionsContract();
+            if (!contract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            const result = await contract.getFunction("getRefundDetails")(user, creator, id);
+            return {
+                refundTo: result.refundTo,
+                useCounterfactualAddress: result.useCounterfactualAddress,
+            };
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * Set refund details for a user's purchase
+     * @param creator The address that created the fraction sale
+     * @param id The unique identifier of the fraction sale
+     * @param refundTo The address to receive refunds
+     * @param useCounterfactualAddress Whether to use counterfactual address for refunds
+     */
+    async function setRefundDetails(creator, id, refundTo, useCounterfactualAddress) {
+        assertSigner(signer);
+        try {
+            const contract = getOffchainFractionsContract();
+            if (!contract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            setIsProcessing(true);
+            // Validate parameters
+            if (!creator || !id || !refundTo) {
+                throw new Error(exports.OffchainFractionsError.INVALID_PARAMETERS);
+            }
+            const owner = await signer.getAddress();
+            // Run a static call first to surface any revert reason
+            try {
+                await contract
+                    .getFunction("setRefundDetails")
+                    .staticCall(creator, id, refundTo, useCounterfactualAddress, {
+                    from: owner,
+                });
+            }
+            catch (staticError) {
+                throw new Error(parseEthersError(staticError));
+            }
+            // Execute the transaction
+            const tx = await contract.getFunction("setRefundDetails")(creator, id, refundTo, useCounterfactualAddress);
+            await tx.wait();
+            return tx.hash;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }
+    /**
+     * Set refund operator approval status
+     * @param refundOperator The address of the refund operator
+     * @param isApproved Whether to approve or revoke the operator
+     */
+    async function setRefundOperatorStatus(refundOperator, isApproved) {
+        assertSigner(signer);
+        try {
+            const contract = getOffchainFractionsContract();
+            if (!contract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            setIsProcessing(true);
+            // Validate parameters
+            if (!refundOperator) {
+                throw new Error(exports.OffchainFractionsError.INVALID_PARAMETERS);
+            }
+            const owner = await signer.getAddress();
+            // Run a static call first to surface any revert reason
+            try {
+                await contract
+                    .getFunction("setRefundOperatorStatus")
+                    .staticCall(refundOperator, isApproved, {
+                    from: owner,
+                });
+            }
+            catch (staticError) {
+                throw new Error(parseEthersError(staticError));
+            }
+            // Execute the transaction
+            const tx = await contract.getFunction("setRefundOperatorStatus")(refundOperator, isApproved);
+            await tx.wait();
+            return tx.hash;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }
+    /**
+     * Check if a refund operator is approved for a user
+     * @param user The user address
+     * @param refundOperator The refund operator address
+     */
+    async function isRefundOperatorApproved(user, refundOperator) {
+        assertSigner(signer);
+        try {
+            const contract = getOffchainFractionsContract();
+            if (!contract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            const result = await contract.getFunction("isRefundOperatorApproved")(user, refundOperator);
+            return result;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * Get refund approval status for a user and operator
+     * @param user The user address
+     * @param refundOperator The refund operator address
+     */
+    async function getRefundApprovalStatus(user, refundOperator) {
+        assertSigner(signer);
+        try {
+            const contract = getOffchainFractionsContract();
+            if (!contract)
+                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+            const result = await contract.getFunction("refundApprovals")(user, refundOperator);
+            return result.isApproved;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
     /**
      * Check if a fraction sale is expired
      * @param creator The address that created the fraction sale
@@ -1642,7 +1921,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             const contract = getOffchainFractionsContract();
             if (!contract)
                 throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-            const { creator, id, stepsToBuy, minStepsToBuy } = params;
+            const { creator, id, stepsToBuy, minStepsToBuy, refundTo, creditTo, useCounterfactualAddressForRefund, } = params;
             const feeData = await signer.provider?.getFeeData();
             const gasPrice = feeData?.gasPrice ?? feeData?.maxFeePerGas ?? 0n;
             if (gasPrice === 0n) {
@@ -1650,7 +1929,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             }
             const estimatedGas = await contract
                 .getFunction("buyFractions")
-                .estimateGas(creator, id, stepsToBuy, minStepsToBuy);
+                .estimateGas(creator, id, stepsToBuy, minStepsToBuy, refundTo, creditTo, useCounterfactualAddressForRefund);
             const estimatedCost = estimatedGas * gasPrice;
             if (ethPriceInUSD) {
                 const estimatedCostInEth = viem.formatEther(estimatedCost);
@@ -1674,6 +1953,13 @@ function useOffchainFractions(signer, CHAIN_ID) {
         // View functions
         getFraction,
         getStepsPurchased,
+        // Refund management functions
+        getRefundWildcardOperator,
+        getRefundDetails,
+        setRefundDetails,
+        setRefundOperatorStatus,
+        isRefundOperatorApproved,
+        getRefundApprovalStatus,
         // Token operations
         approveToken,
         checkTokenAllowance,
@@ -3118,4 +3404,4 @@ exports.regionMetadata = regionMetadata;
 exports.usStates = usStates;
 exports.useForwarder = useForwarder;
 exports.useOffchainFractions = useOffchainFractions;
-//# sourceMappingURL=farms-router-DuVI7Pig.js.map
+//# sourceMappingURL=farms-router-DhAOciuN.js.map