@glowlabs-org/utils 0.2.174 → 0.2.176

package/dist/cjs/browser.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var calculateFarmEfficiency = require('./calculate-farm-efficiency-CBI3L6Cz.js');
+var calculateFarmEfficiency = require('./calculate-farm-efficiency-z9p1HOmd.js');
 require('decimal.js');
 var viem = require('viem');
 require('ethers');

package/dist/cjs/{calculate-farm-efficiency-CBI3L6Cz.js → calculate-farm-efficiency-z9p1HOmd.js}

@@ -542,7 +542,16 @@ function assertSigner(maybeSigner) {
         throw new Error(exports.ForwarderError.SIGNER_NOT_AVAILABLE);
     }
 }
-function useForwarder(signer, CHAIN_ID, publicClient) {
+// Type-guard style helper to ensure a wallet client exists throughout the rest of the function.
+function assertWalletClient$2(maybeWalletClient) {
+    if (!maybeWalletClient) {
+        throw new Error(exports.ForwarderError.SIGNER_NOT_AVAILABLE);
+    }
+    if (!maybeWalletClient.account) {
+        throw new Error("Wallet client must have an account");
+    }
+}
+function useForwarder(signer, CHAIN_ID, publicClient, walletClient) {
     // Use dynamic addresses based on chain configuration
     const ADDRESSES = getAddresses(CHAIN_ID);
     // Framework-agnostic processing flag
@@ -550,7 +559,13 @@ function useForwarder(signer, CHAIN_ID, publicClient) {
     const setIsProcessing = (value) => {
         isProcessing = value;
     };
-    // Returns a contract instance for Forwarder
+    // Helper to assert public client is available
+    function assertPublicClient(maybePublicClient) {
+        if (!maybePublicClient) {
+            throw new Error("Public client not available");
+        }
+    }
+    // Returns a contract instance for Forwarder (Legacy Ethers)
     function getForwarderContract() {
         assertSigner(signer);
         return new ethers.Contract(ADDRESSES.FORWARDER, FORWARDER_ABI, signer);
@@ -673,21 +688,44 @@ function useForwarder(signer, CHAIN_ID, publicClient) {
      * @param currency The currency to approve
      */
     async function approveToken(amount, currency = "USDC") {
-        assertSigner(signer);
         try {
-            const tokenContract = getTokenContract(currency);
-            if (!tokenContract)
-                throw new Error(exports.ForwarderError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
-            // Approve only the specific amount needed
-            const approveTx = await tokenContract.approve(ADDRESSES.FORWARDER, amount);
-            if (publicClient) {
-                await waitForViemTransactionWithRetry(publicClient, approveTx.hash, {
-                    timeoutMs: 60000,
-                    pollIntervalMs: 2000,
+            // Get token address
+            let tokenAddress;
+            switch (currency) {
+                case "USDC":
+                    tokenAddress = ADDRESSES.USDC;
+                    break;
+                case "GLW":
+                    tokenAddress = ADDRESSES.GLW;
+                    break;
+                case "USDG":
+                    tokenAddress = ADDRESSES.USDG;
+                    break;
+                default:
+                    throw new Error(`Currency ${currency} not yet supported. Only USDC, GLW, and USDG are currently supported.`);
+            }
+            // If walletClient and publicClient are available, use Viem (better for mobile)
+            if (walletClient && publicClient) {
+                assertWalletClient$2(walletClient);
+                assertPublicClient(publicClient);
+                const hash = await walletClient.writeContract({
+                    address: tokenAddress,
+                    abi: ERC20_ABI,
+                    functionName: "approve",
+                    args: [ADDRESSES.FORWARDER, amount],
+                    chain: walletClient.chain,
+                    account: walletClient.account,
                 });
+                await waitForViemTransactionWithRetry(publicClient, hash);
             }
             else {
+                // Fallback to Ethers
+                assertSigner(signer);
+                const tokenContract = getTokenContract(currency);
+                if (!tokenContract)
+                    throw new Error(exports.ForwarderError.CONTRACT_NOT_AVAILABLE);
+                const approveTx = await tokenContract.approve(ADDRESSES.FORWARDER, amount);
                 await waitForEthersTransactionWithRetry(signer, approveTx.hash, {
                     timeoutMs: 60000,
                     pollIntervalMs: 2000,
@@ -696,6 +734,9 @@ function useForwarder(signer, CHAIN_ID, publicClient) {
             return true;
         }
         catch (error) {
+            if (walletClient && publicClient) {
+                throw new Error(parseViemError(error));
+            }
             throw new Error(parseEthersError(error));
         }
         finally {
@@ -707,16 +748,9 @@ function useForwarder(signer, CHAIN_ID, publicClient) {
      * @param params Forward parameters including type, amount, and required fields
      */
     async function forwardTokens(params) {
-        assertSigner(signer);
         try {
-            const forwarderContract = getForwarderContract();
-            if (!forwarderContract)
-                throw new Error(exports.ForwarderError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
             const { amount, currency = "USDC" } = params;
-            const tokenContract = getTokenContract(currency);
-            if (!tokenContract)
-                throw new Error(exports.ForwarderError.CONTRACT_NOT_AVAILABLE);
             sentryAddBreadcrumb({
                 category: "forwarder",
                 message: "forwardTokens.start",
@@ -733,50 +767,16 @@ function useForwarder(signer, CHAIN_ID, publicClient) {
                     userAddress: params.userAddress,
                 },
             });
-            const owner = await signer.getAddress();
-            // Construct the appropriate message for this forward type
-            const message = constructForwardMessage(params);
-            // Special handling: PayAuditFees can ONLY be USDC, and must call forward()
+            // Special handling checks
             const isAuditFees = params.type === TRANSFER_TYPES.PayAuditFees;
             if (isAuditFees && currency !== "USDC") {
                 throw new Error("PayAuditFees only supports USDC");
             }
-            // CommitKickstarter supports only USDC or USDG (GLW not allowed)
             const isCommitKickstarter = params.type === TRANSFER_TYPES.CommitKickstarter;
             if (isCommitKickstarter && currency === "GLW") {
                 throw new Error("CommitKickstarter supports only USDC or USDG");
             }
-            // Check allowance and approve if necessary
-            const allowance = await tokenContract.allowance(owner, ADDRESSES.FORWARDER);
-            console.log("allowance", allowance.toString());
-            if (allowance < amount) {
-                try {
-                    const approveTx = await tokenContract.approve(ADDRESSES.FORWARDER, ethers.MaxUint256);
-                    if (publicClient) {
-                        await waitForViemTransactionWithRetry(publicClient, approveTx.hash, {
-                            timeoutMs: 60000,
-                            pollIntervalMs: 2000,
-                        });
-                    }
-                    else {
-                        await waitForEthersTransactionWithRetry(signer, approveTx.hash, {
-                            timeoutMs: 60000,
-                            pollIntervalMs: 2000,
-                        });
-                    }
-                }
-                catch (approveError) {
-                    sentryCaptureException(approveError, {
-                        action: "forwardTokens.approve",
-                        chainId: CHAIN_ID,
-                        spender: ADDRESSES.FORWARDER,
-                        amount: ethers.MaxUint256.toString(),
-                        currency,
-                    });
-                    throw new Error(parseEthersError(approveError) || "Token approval failed");
-                }
-            }
-            // Get the token address based on currency
+            // Get token address
             let tokenAddress;
             switch (currency) {
                 case "USDC":
@@ -791,62 +791,206 @@ function useForwarder(signer, CHAIN_ID, publicClient) {
                 default:
                     throw new Error(`Unsupported currency for forwarding: ${currency}`);
             }
-            // Determine sendToCounterfactualWallet: false for audit fees (paid in USDC directly)
+            const message = constructForwardMessage(params);
             const sendToCounterfactualWallet = !isAuditFees;
-            // Run a static call first to surface any revert reason (ethers v6)
-            try {
+            // Handle transaction based on available client
+            if (walletClient && publicClient) {
+                // --- VIEM IMPLEMENTATION ---
+                assertWalletClient$2(walletClient);
+                assertPublicClient(publicClient);
+                const owner = walletClient.account.address;
+                // Check allowance
+                const allowance = (await publicClient.readContract({
+                    address: tokenAddress,
+                    abi: ERC20_ABI,
+                    functionName: "allowance",
+                    args: [owner, ADDRESSES.FORWARDER],
+                }));
+                if (allowance < amount) {
+                    try {
+                        const approveHash = await walletClient.writeContract({
+                            address: tokenAddress,
+                            abi: ERC20_ABI,
+                            functionName: "approve",
+                            args: [ADDRESSES.FORWARDER, ethers.MaxUint256],
+                            chain: walletClient.chain,
+                            account: walletClient.account,
+                        });
+                        await waitForViemTransactionWithRetry(publicClient, approveHash);
+                    }
+                    catch (approveError) {
+                        sentryCaptureException(approveError, {
+                            action: "forwardTokens.approve",
+                            chainId: CHAIN_ID,
+                            spender: ADDRESSES.FORWARDER,
+                            amount: ethers.MaxUint256.toString(),
+                            currency,
+                        });
+                        throw new Error(parseViemError(approveError) || "Token approval failed");
+                    }
+                }
+                // Simulate
+                try {
+                    if (!isAuditFees && currency === "USDC") {
+                        await publicClient.simulateContract({
+                            address: ADDRESSES.FORWARDER,
+                            abi: FORWARDER_ABI,
+                            functionName: "swapUSDCAndForwardUSDG",
+                            args: [
+                                amount,
+                                ADDRESSES.FOUNDATION_WALLET,
+                                sendToCounterfactualWallet,
+                                message,
+                            ],
+                            account: walletClient.account,
+                        });
+                    }
+                    else {
+                        await publicClient.simulateContract({
+                            address: ADDRESSES.FORWARDER,
+                            abi: FORWARDER_ABI,
+                            functionName: "forward",
+                            args: [
+                                tokenAddress,
+                                (isAuditFees
+                                    ? ADDRESSES.AUDIT_FEE_WALLET
+                                    : ADDRESSES.FOUNDATION_WALLET),
+                                amount,
+                                sendToCounterfactualWallet,
+                                message,
+                            ],
+                            account: walletClient.account,
+                        });
+                    }
+                }
+                catch (staticError) {
+                    sentryCaptureException(staticError, {
+                        action: "forwardTokens.simulate",
+                        chainId: CHAIN_ID,
+                        function: !isAuditFees && currency === "USDC"
+                            ? "swapUSDCAndForwardUSDG"
+                            : "forward",
+                        tokenAddress,
+                        amount: amount.toString(),
+                        currency,
+                        isAuditFees,
+                    });
+                    throw new Error(parseViemError(staticError));
+                }
+                // Write
+                let hash;
                 if (!isAuditFees && currency === "USDC") {
-                    await forwarderContract
-                        .getFunction("swapUSDCAndForwardUSDG")
-                        .staticCall(amount, ADDRESSES.FOUNDATION_WALLET, sendToCounterfactualWallet, message, {
-                        from: owner,
+                    hash = await walletClient.writeContract({
+                        address: ADDRESSES.FORWARDER,
+                        abi: FORWARDER_ABI,
+                        functionName: "swapUSDCAndForwardUSDG",
+                        args: [
+                            amount,
+                            ADDRESSES.FOUNDATION_WALLET,
+                            sendToCounterfactualWallet,
+                            message,
+                        ],
+                        chain: walletClient.chain,
+                        account: walletClient.account,
                     });
                 }
                 else {
-                    await forwarderContract
-                        .getFunction("forward")
-                        .staticCall(tokenAddress, isAuditFees
-                        ? ADDRESSES.AUDIT_FEE_WALLET
-                        : ADDRESSES.FOUNDATION_WALLET, amount, sendToCounterfactualWallet, message, { from: owner });
+                    hash = await walletClient.writeContract({
+                        address: ADDRESSES.FORWARDER,
+                        abi: FORWARDER_ABI,
+                        functionName: "forward",
+                        args: [
+                            tokenAddress,
+                            (isAuditFees
+                                ? ADDRESSES.AUDIT_FEE_WALLET
+                                : ADDRESSES.FOUNDATION_WALLET),
+                            amount,
+                            sendToCounterfactualWallet,
+                            message,
+                        ],
+                        chain: walletClient.chain,
+                        account: walletClient.account,
+                    });
                 }
-            }
-            catch (staticError) {
-                sentryCaptureException(staticError, {
-                    action: "forwardTokens.staticCall",
-                    chainId: CHAIN_ID,
-                    function: !isAuditFees && currency === "USDC"
-                        ? "swapUSDCAndForwardUSDG"
-                        : "forward",
-                    tokenAddress,
-                    amount: amount.toString(),
-                    currency,
-                    isAuditFees,
-                });
-                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);
-            }
-            if (publicClient) {
-                await waitForViemTransactionWithRetry(publicClient, tx.hash, {
-                    timeoutMs: 60000,
-                    pollIntervalMs: 2000,
-                });
+                await waitForViemTransactionWithRetry(publicClient, hash);
+                return hash;
             }
             else {
+                // --- ETHERS IMPLEMENTATION (Legacy) ---
+                assertSigner(signer);
+                const forwarderContract = getForwarderContract();
+                if (!forwarderContract)
+                    throw new Error(exports.ForwarderError.CONTRACT_NOT_AVAILABLE);
+                const tokenContract = getTokenContract(currency);
+                if (!tokenContract)
+                    throw new Error(exports.ForwarderError.CONTRACT_NOT_AVAILABLE);
+                const owner = await signer.getAddress();
+                // Check allowance
+                const allowance = await tokenContract.allowance(owner, ADDRESSES.FORWARDER);
+                if (allowance < amount) {
+                    try {
+                        const approveTx = await tokenContract.approve(ADDRESSES.FORWARDER, ethers.MaxUint256);
+                        await waitForEthersTransactionWithRetry(signer, approveTx.hash, {
+                            timeoutMs: 60000,
+                            pollIntervalMs: 2000,
+                        });
+                    }
+                    catch (approveError) {
+                        sentryCaptureException(approveError, {
+                            action: "forwardTokens.approve",
+                            chainId: CHAIN_ID,
+                            spender: ADDRESSES.FORWARDER,
+                            amount: ethers.MaxUint256.toString(),
+                            currency,
+                        });
+                        throw new Error(parseEthersError(approveError) || "Token approval failed");
+                    }
+                }
+                // Determine function and call static
+                try {
+                    if (!isAuditFees && currency === "USDC") {
+                        await forwarderContract
+                            .getFunction("swapUSDCAndForwardUSDG")
+                            .staticCall(amount, ADDRESSES.FOUNDATION_WALLET, sendToCounterfactualWallet, message, { from: owner });
+                    }
+                    else {
+                        await forwarderContract
+                            .getFunction("forward")
+                            .staticCall(tokenAddress, isAuditFees
+                            ? ADDRESSES.AUDIT_FEE_WALLET
+                            : ADDRESSES.FOUNDATION_WALLET, amount, sendToCounterfactualWallet, message, { from: owner });
+                    }
+                }
+                catch (staticError) {
+                    sentryCaptureException(staticError, {
+                        action: "forwardTokens.staticCall",
+                        chainId: CHAIN_ID,
+                        function: !isAuditFees && currency === "USDC"
+                            ? "swapUSDCAndForwardUSDG"
+                            : "forward",
+                        tokenAddress,
+                        amount: amount.toString(),
+                        currency,
+                        isAuditFees,
+                    });
+                    throw new Error(parseEthersError(staticError));
+                }
+                // Execute 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 waitForEthersTransactionWithRetry(signer, tx.hash, {
                     timeoutMs: 60000,
                     pollIntervalMs: 2000,
                 });
+                return tx.hash;
             }
-            return tx.hash;
         }
         catch (txError) {
             sentryCaptureException(txError, {
@@ -861,6 +1005,9 @@ function useForwarder(signer, CHAIN_ID, publicClient) {
                 kickstarterId: params.kickstarterId,
                 userAddress: params.userAddress,
             });
+            if (walletClient && publicClient) {
+                throw new Error(parseViemError(txError));
+            }
             throw new Error(parseEthersError(txError));
         }
         finally {
@@ -912,6 +1059,7 @@ function useForwarder(signer, CHAIN_ID, publicClient) {
             type: TRANSFER_TYPES.PayProtocolFee,
             currency,
             applicationId,
+            regionId: undefined, // Fix missing argument
         });
     }
     /**
@@ -931,7 +1079,10 @@ function useForwarder(signer, CHAIN_ID, publicClient) {
      * Forward USDC to mint GCTL and stake to a region
      */
     async function mintGCTLAndStake(amount, userAddress, regionId, currency = "USDC") {
-        assertSigner(signer);
+        // If using WalletClient, we don't strictly need a signer here anymore for forwardTokens
+        // But other methods might still rely on it.
+        if (!walletClient)
+            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.");
@@ -948,7 +1099,8 @@ function useForwarder(signer, CHAIN_ID, publicClient) {
      * Forward USDC to mint GCTL (existing functionality, keeping for compatibility)
      */
     async function mintGCTL(amount, userAddress, currency = "USDC") {
-        assertSigner(signer);
+        if (!walletClient)
+            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.");
@@ -1132,7 +1284,7 @@ function useForwarder(signer, CHAIN_ID, publicClient) {
         },
         addresses: ADDRESSES,
         // Signer availability
-        isSignerAvailable: !!signer,
+        isSignerAvailable: !!signer || !!walletClient,
     };
 }
 
@@ -1864,6 +2016,17 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                     account: walletClient.account,
                 });
                 await waitForViemTransactionWithRetry(publicClient, approveHash);
+                // Verify allowance is reflected before proceeding (RPC lag mitigation)
+                const maxAllowanceChecks = 5;
+                const allowanceCheckDelayMs = 500;
+                for (let i = 0; i < maxAllowanceChecks; i++) {
+                    const updatedAllowance = await checkTokenAllowance(owner, fractionData.token);
+                    if (updatedAllowance >= requiredAmount)
+                        break;
+                    if (i < maxAllowanceChecks - 1) {
+                        await new Promise((r) => setTimeout(r, allowanceCheckDelayMs));
+                    }
+                }
             }
             // Run a simulation first to surface any revert reason
             try {
@@ -5371,4 +5534,4 @@ exports.useOffchainFractions = useOffchainFractions;
 exports.useRewardsKernel = useRewardsKernel;
 exports.waitForEthersTransactionWithRetry = waitForEthersTransactionWithRetry;
 exports.waitForViemTransactionWithRetry = waitForViemTransactionWithRetry;
-//# sourceMappingURL=calculate-farm-efficiency-CBI3L6Cz.js.map
+//# sourceMappingURL=calculate-farm-efficiency-z9p1HOmd.js.map