@glowlabs-org/utils 0.2.145 → 0.2.147

package/dist/cjs/browser.js

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

package/dist/cjs/{farms-router-C8V_F0vY.js → farms-router-Cg0-zSMT.js}

@@ -274,8 +274,8 @@ const sepoliaAddresses = {
     USDC: "0x93c898be98cd2618ba84a6dccf5003d3bbe40356",
     USDG_UNISWAP: "0x2a085A3aEA8982396533327c854753Ce521B666d",
     GLW_UNISWAP: "0x8e27016D0B866a56CE74A1a280c749dD679bb0Fa",
-    FORWARDER: "0xDaC24F18171224eeaf6a9B38f5C5081aDbDff969",
-    OFFCHAIN_FRACTIONS: "0x7D97528eeF8B8D17AA1Ba3307Ed39b07b3A1b69B",
+    FORWARDER: "0xe7A366482899e2Ed29c9504F4792B8D1c67066ff",
+    OFFCHAIN_FRACTIONS: "0x5Ad30F90AFEf1279157A5055AAd2d8c1529a05D2",
     COUNTERFACTUAL_HOLDER_FACTORY: "0x2c3AB887746F6f4a8a4b9Db6aC800eb71945509A",
     FOUNDATION_WALLET: "0x5e230FED487c86B90f6508104149F087d9B1B0A7",
     FOUNDATION_HUB_MANAGER_WALLET: "0x5252FdA14A149c01EA5A1D6514a9c1369E4C70b4",
@@ -354,6 +354,7 @@ const DEFAULT_OPTIONS = {
     maxRetries: 3,
     timeoutMs: 60000,
     enableLogging: true,
+    pollIntervalMs: 2000,
 };
 /**
  * Enhanced transaction receipt handler with retry logic for viem
@@ -362,66 +363,46 @@ const DEFAULT_OPTIONS = {
  * @param options Retry configuration options
  */
 async function waitForViemTransactionWithRetry(publicClient, hash, options = {}) {
-    const { maxRetries, timeoutMs, enableLogging } = {
+    const { maxRetries, timeoutMs, enableLogging, pollIntervalMs } = {
         ...DEFAULT_OPTIONS,
         ...options,
     };
-    let lastError = null;
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    const deadline = Date.now() + timeoutMs;
+    let consecutiveErrors = 0;
+    while (Date.now() < deadline) {
         try {
-            // Wait for transaction receipt with timeout
-            const receipt = await publicClient.waitForTransactionReceipt({
-                hash,
-                timeout: timeoutMs,
-            });
-            // Check transaction status
-            if (receipt.status === "reverted") {
-                throw new Error(`Transaction ${hash} was reverted on-chain`);
-            }
-            if (enableLogging) {
-                console.log(`Transaction ${hash} confirmed successfully in block ${receipt.blockNumber}`);
+            const receipt = await publicClient.getTransactionReceipt({ hash });
+            if (receipt) {
+                if (receipt.status === "reverted") {
+                    throw new Error(`Transaction ${hash} was reverted on-chain`);
+                }
+                if (enableLogging) {
+                    console.log(`Transaction ${hash} confirmed successfully in block ${receipt.blockNumber}`);
+                }
+                return;
             }
-            return; // Success, exit the function
         }
         catch (error) {
-            lastError = error;
-            // Check if it's a timeout or not found error
             const errorMessage = parseViemError(error);
-            const isRetryableError = errorMessage.includes("could not be found") ||
-                errorMessage.includes("timeout") ||
-                errorMessage.includes("timed out") ||
+            // Treat not found/receipt missing as retryable without counting towards errors
+            const isNotFound = errorMessage.includes("not found") ||
+                errorMessage.includes("could not be found") ||
                 errorMessage.includes("receipt") ||
-                errorMessage.includes("not be processed");
-            if (!isRetryableError || attempt === maxRetries) {
-                // If it's not a retryable error or we've exhausted retries, throw
-                throw new Error(`Transaction failed after ${attempt} attempts: ${errorMessage}`);
-            }
-            // Wait before retrying (exponential backoff)
-            const delay = Math.min(2000 * Math.pow(2, attempt - 1), 10000);
-            if (enableLogging) {
-                console.warn(`Transaction receipt not found (attempt ${attempt}/${maxRetries}), retrying in ${delay}ms...`);
-            }
-            await new Promise((resolve) => setTimeout(resolve, delay));
-            // Check transaction status before retrying
-            try {
-                const transaction = await publicClient.getTransaction({ hash });
-                if (!transaction) {
-                    throw new Error("Transaction not found in mempool or blockchain");
-                }
-                if (enableLogging) {
-                    console.log(`Transaction ${hash} found in ${transaction.blockNumber ? "block" : "mempool"}, waiting for confirmation...`);
+                errorMessage.includes("not confirmed") ||
+                errorMessage.includes("TransactionReceiptNotFound");
+            if (!isNotFound) {
+                consecutiveErrors++;
+                if (consecutiveErrors >= maxRetries) {
+                    throw new Error(`Transaction failed after ${consecutiveErrors} attempts: ${errorMessage}`);
                 }
-            }
-            catch (txError) {
                 if (enableLogging) {
-                    console.warn(`Could not fetch transaction ${hash}: ${parseViemError(txError)}`);
+                    console.warn(`Error fetching receipt (attempt ${consecutiveErrors}/${maxRetries}), retrying in ${pollIntervalMs}ms...`);
                 }
-                // Continue with retry anyway in case it's just an RPC issue
             }
         }
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
     }
-    // This should never be reached, but just in case
-    throw new Error(`Transaction failed after ${maxRetries} attempts: ${parseViemError(lastError)}`);
+    throw new Error(`Transaction receipt not found within ${timeoutMs}ms`);
 }
 /**
  * Enhanced transaction receipt handler with retry logic for ethers.js
@@ -430,82 +411,42 @@ async function waitForViemTransactionWithRetry(publicClient, hash, options = {})
  * @param options Retry configuration options
  */
 async function waitForEthersTransactionWithRetry(signer, txHash, options = {}) {
-    const { maxRetries, timeoutMs, enableLogging } = {
+    const { maxRetries, timeoutMs, enableLogging, pollIntervalMs } = {
         ...DEFAULT_OPTIONS,
         ...options,
     };
-    let lastError = null;
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    const provider = signer.provider;
+    if (!provider) {
+        throw new Error("Provider not available");
+    }
+    const deadline = Date.now() + timeoutMs;
+    let consecutiveErrors = 0;
+    while (Date.now() < deadline) {
         try {
-            // Wait for transaction receipt with timeout
-            const provider = signer.provider;
-            if (!provider) {
-                throw new Error("Provider not available");
-            }
-            // Create a timeout promise
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error("Transaction receipt timeout")), timeoutMs);
-            });
-            // Race between waiting for receipt and timeout
-            const receipt = await Promise.race([
-                provider.waitForTransaction(txHash, 1, timeoutMs),
-                timeoutPromise,
-            ]);
-            if (!receipt) {
-                throw new Error("Transaction receipt not found");
-            }
-            // Check transaction status (ethers.js uses status: 0 for failed, 1 for success)
-            if (receipt.status === 0) {
-                throw new Error(`Transaction ${txHash} was reverted on-chain`);
-            }
-            if (enableLogging) {
-                console.log(`Transaction ${txHash} confirmed successfully in block ${receipt.blockNumber}`);
+            const receipt = await provider.getTransactionReceipt(txHash);
+            if (receipt) {
+                if (receipt.status === 0) {
+                    throw new Error(`Transaction ${txHash} was reverted on-chain`);
+                }
+                if (enableLogging) {
+                    console.log(`Transaction ${txHash} confirmed successfully in block ${receipt.blockNumber}`);
+                }
+                return;
             }
-            return; // Success, exit the function
         }
         catch (error) {
-            lastError = error;
-            // Check if it's a timeout or not found error
             const errorMessage = parseEthersError(error);
-            const isRetryableError = errorMessage.includes("could not be found") ||
-                errorMessage.includes("timeout") ||
-                errorMessage.includes("timed out") ||
-                errorMessage.includes("receipt") ||
-                errorMessage.includes("not be processed") ||
-                errorMessage.includes("Transaction receipt timeout");
-            if (!isRetryableError || attempt === maxRetries) {
-                // If it's not a retryable error or we've exhausted retries, throw
-                throw new Error(`Transaction failed after ${attempt} attempts: ${errorMessage}`);
+            consecutiveErrors++;
+            if (consecutiveErrors >= maxRetries) {
+                throw new Error(`Transaction failed after ${consecutiveErrors} attempts: ${errorMessage}`);
             }
-            // Wait before retrying (exponential backoff)
-            const delay = Math.min(2000 * Math.pow(2, attempt - 1), 10000);
             if (enableLogging) {
-                console.warn(`Transaction receipt not found (attempt ${attempt}/${maxRetries}), retrying in ${delay}ms...`);
-            }
-            await new Promise((resolve) => setTimeout(resolve, delay));
-            // Check transaction status before retrying
-            try {
-                const provider = signer.provider;
-                if (provider) {
-                    const transaction = await provider.getTransaction(txHash);
-                    if (!transaction) {
-                        throw new Error("Transaction not found in mempool or blockchain");
-                    }
-                    if (enableLogging) {
-                        console.log(`Transaction ${txHash} found in ${transaction.blockNumber ? "block" : "mempool"}, waiting for confirmation...`);
-                    }
-                }
-            }
-            catch (txError) {
-                if (enableLogging) {
-                    console.warn(`Could not fetch transaction ${txHash}: ${parseEthersError(txError)}`);
-                }
-                // Continue with retry anyway in case it's just an RPC issue
+                console.warn(`Error fetching receipt (attempt ${consecutiveErrors}/${maxRetries}), retrying in ${pollIntervalMs}ms...`);
             }
         }
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
     }
-    // This should never be reached, but just in case
-    throw new Error(`Transaction failed after ${maxRetries} attempts: ${parseEthersError(lastError)}`);
+    throw new Error(`Transaction receipt not found within ${timeoutMs}ms`);
 }
 
 let configuredClient = null;
@@ -725,7 +666,10 @@ function useForwarder(signer, CHAIN_ID) {
             setIsProcessing(true);
             // Approve only the specific amount needed
             const approveTx = await tokenContract.approve(ADDRESSES.FORWARDER, amount);
-            await waitForEthersTransactionWithRetry(signer, approveTx.hash);
+            await waitForEthersTransactionWithRetry(signer, approveTx.hash, {
+                timeoutMs: 30000,
+                pollIntervalMs: 2000,
+            });
             return true;
         }
         catch (error) {
@@ -785,7 +729,10 @@ function useForwarder(signer, CHAIN_ID) {
             if (allowance < amount) {
                 try {
                     const approveTx = await tokenContract.approve(ADDRESSES.FORWARDER, ethers.MaxUint256);
-                    await waitForEthersTransactionWithRetry(signer, approveTx.hash);
+                    await waitForEthersTransactionWithRetry(signer, approveTx.hash, {
+                        timeoutMs: 30000,
+                        pollIntervalMs: 2000,
+                    });
                 }
                 catch (approveError) {
                     sentryCaptureException(approveError, {
@@ -856,7 +803,10 @@ function useForwarder(signer, CHAIN_ID) {
                     ? ADDRESSES.AUDIT_FEE_WALLET
                     : ADDRESSES.FOUNDATION_WALLET, amount, sendToCounterfactualWallet, message);
             }
-            await waitForEthersTransactionWithRetry(signer, tx.hash);
+            await waitForEthersTransactionWithRetry(signer, tx.hash, {
+                timeoutMs: 30000,
+                pollIntervalMs: 2000,
+            });
             return tx.hash;
         }
         catch (txError) {
@@ -1091,7 +1041,10 @@ function useForwarder(signer, CHAIN_ID) {
             setIsProcessing(true);
             // Try to call mint function (common for test tokens)
             const tx = await usdcContract.mint(recipient, amount);
-            await waitForEthersTransactionWithRetry(signer, tx.hash);
+            await waitForEthersTransactionWithRetry(signer, tx.hash, {
+                timeoutMs: 30000,
+                pollIntervalMs: 2000,
+            });
             return tx.hash;
         }
         catch (error) {
@@ -4283,4 +4236,4 @@ exports.useForwarder = useForwarder;
 exports.useOffchainFractions = useOffchainFractions;
 exports.waitForEthersTransactionWithRetry = waitForEthersTransactionWithRetry;
 exports.waitForViemTransactionWithRetry = waitForViemTransactionWithRetry;
-//# sourceMappingURL=farms-router-C8V_F0vY.js.map
+//# sourceMappingURL=farms-router-Cg0-zSMT.js.map