@glowlabs-org/utils 0.2.140 → 0.2.142

package/dist/cjs/{farms-router-Darq9ZsF.js → farms-router-CCva--xp.js}

@@ -303,15 +303,27 @@ const DECIMALS_BY_TOKEN = {
     GLW: 18,
 };
 
-exports.ForwarderError = void 0;
-(function (ForwarderError) {
-    ForwarderError["CONTRACT_NOT_AVAILABLE"] = "Contract not available";
-    ForwarderError["SIGNER_NOT_AVAILABLE"] = "Signer not available";
-    ForwarderError["UNKNOWN_ERROR"] = "Unknown error";
-    ForwarderError["INVALID_FORWARD_TYPE"] = "Invalid forward type";
-    ForwarderError["MISSING_REQUIRED_PARAMS"] = "Missing required parameters";
-})(exports.ForwarderError || (exports.ForwarderError = {}));
-// Utility to extract the most useful revert reason from an ethers error object
+// Error parsing utilities
+function parseViemError(error) {
+    if (!error)
+        return "Unknown error";
+    // Check if it's a viem BaseError
+    if (error instanceof Error) {
+        // For contract revert errors
+        if (error.cause?.reason) {
+            return error.cause.reason;
+        }
+        // For viem's shortMessage
+        if (error.shortMessage) {
+            return error.shortMessage;
+        }
+        // Fallback to regular message
+        if (error.message) {
+            return error.message;
+        }
+    }
+    return "Unknown error";
+}
 function parseEthersError(error) {
     if (!error)
         return "Unknown error";
@@ -336,8 +348,174 @@ function parseEthersError(error) {
         return possibleError.reason;
     if (possibleError?.message)
         return possibleError.message;
-    return exports.ForwarderError.UNKNOWN_ERROR;
+    return "Unknown error";
+}
+const DEFAULT_OPTIONS = {
+    maxRetries: 3,
+    timeoutMs: 60000,
+    enableLogging: true,
+};
+/**
+ * Enhanced transaction receipt handler with retry logic for viem
+ * @param publicClient The viem public client
+ * @param hash The transaction hash
+ * @param options Retry configuration options
+ */
+async function waitForViemTransactionWithRetry(publicClient, hash, options = {}) {
+    const { maxRetries, timeoutMs, enableLogging } = {
+        ...DEFAULT_OPTIONS,
+        ...options,
+    };
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        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}`);
+            }
+            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") ||
+                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...`);
+                }
+            }
+            catch (txError) {
+                if (enableLogging) {
+                    console.warn(`Could not fetch transaction ${hash}: ${parseViemError(txError)}`);
+                }
+                // Continue with retry anyway in case it's just an RPC issue
+            }
+        }
+    }
+    // This should never be reached, but just in case
+    throw new Error(`Transaction failed after ${maxRetries} attempts: ${parseViemError(lastError)}`);
+}
+/**
+ * Enhanced transaction receipt handler with retry logic for ethers.js
+ * @param signer The ethers signer
+ * @param txHash The transaction hash
+ * @param options Retry configuration options
+ */
+async function waitForEthersTransactionWithRetry(signer, txHash, options = {}) {
+    const { maxRetries, timeoutMs, enableLogging } = {
+        ...DEFAULT_OPTIONS,
+        ...options,
+    };
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        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}`);
+            }
+            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}`);
+            }
+            // 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
+            }
+        }
+    }
+    // This should never be reached, but just in case
+    throw new Error(`Transaction failed after ${maxRetries} attempts: ${parseEthersError(lastError)}`);
 }
+
+exports.ForwarderError = void 0;
+(function (ForwarderError) {
+    ForwarderError["CONTRACT_NOT_AVAILABLE"] = "Contract not available";
+    ForwarderError["SIGNER_NOT_AVAILABLE"] = "Signer not available";
+    ForwarderError["UNKNOWN_ERROR"] = "Unknown error";
+    ForwarderError["INVALID_FORWARD_TYPE"] = "Invalid forward type";
+    ForwarderError["MISSING_REQUIRED_PARAMS"] = "Missing required parameters";
+})(exports.ForwarderError || (exports.ForwarderError = {}));
 // Type-guard style helper to ensure a signer exists throughout the rest of the function.
 function assertSigner(maybeSigner) {
     if (!maybeSigner) {
@@ -483,7 +661,7 @@ function useForwarder(signer, CHAIN_ID) {
             setIsProcessing(true);
             // Approve only the specific amount needed
             const approveTx = await tokenContract.approve(ADDRESSES.FORWARDER, amount);
-            await approveTx.wait();
+            await waitForEthersTransactionWithRetry(signer, approveTx.hash);
             return true;
         }
         catch (error) {
@@ -527,7 +705,7 @@ function useForwarder(signer, CHAIN_ID) {
             if (allowance < amount) {
                 try {
                     const approveTx = await tokenContract.approve(ADDRESSES.FORWARDER, ethers.MaxUint256);
-                    await approveTx.wait();
+                    await waitForEthersTransactionWithRetry(signer, approveTx.hash);
                 }
                 catch (approveError) {
                     throw new Error(parseEthersError(approveError) || "Token approval failed");
@@ -580,7 +758,7 @@ function useForwarder(signer, CHAIN_ID) {
                     ? ADDRESSES.AUDIT_FEE_WALLET
                     : ADDRESSES.FOUNDATION_WALLET, amount, sendToCounterfactualWallet, message);
             }
-            await tx.wait();
+            await waitForEthersTransactionWithRetry(signer, tx.hash);
             return tx.hash;
         }
         catch (txError) {
@@ -803,7 +981,7 @@ function useForwarder(signer, CHAIN_ID) {
             setIsProcessing(true);
             // Try to call mint function (common for test tokens)
             const tx = await usdcContract.mint(recipient, amount);
-            await tx.wait();
+            await waitForEthersTransactionWithRetry(signer, tx.hash);
             return tx.hash;
         }
         catch (error) {
@@ -1320,27 +1498,6 @@ exports.OffchainFractionsError = void 0;
     OffchainFractionsError["INSUFFICIENT_BALANCE"] = "Insufficient balance";
     OffchainFractionsError["INSUFFICIENT_ALLOWANCE"] = "Insufficient allowance";
 })(exports.OffchainFractionsError || (exports.OffchainFractionsError = {}));
-// Utility to extract the most useful revert reason from a viem error object
-function parseViemError(error) {
-    if (!error)
-        return "Unknown error";
-    // Check if it's a viem BaseError
-    if (error instanceof Error) {
-        // For contract revert errors
-        if (error.cause?.reason) {
-            return error.cause.reason;
-        }
-        // For viem's shortMessage
-        if (error.shortMessage) {
-            return error.shortMessage;
-        }
-        // Fallback to regular message
-        if (error.message) {
-            return error.message;
-        }
-    }
-    return exports.OffchainFractionsError.UNKNOWN_ERROR;
-}
 // Type-guard style helper to ensure a wallet client exists throughout the rest of the function.
 function assertWalletClient(maybeWalletClient) {
     if (!maybeWalletClient) {
@@ -1422,9 +1579,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                 chain: walletClient.chain,
                 account: walletClient.account,
             });
-            await publicClient.waitForTransactionReceipt({
-                hash,
-            });
+            await waitForViemTransactionWithRetry(publicClient, hash);
             return true;
         }
         catch (error) {
@@ -1496,9 +1651,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                 chain: walletClient.chain,
                 account: walletClient.account,
             });
-            await publicClient.waitForTransactionReceipt({
-                hash,
-            });
+            await waitForViemTransactionWithRetry(publicClient, hash);
             return hash;
         }
         catch (error) {
@@ -1551,9 +1704,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                     chain: walletClient.chain,
                     account: walletClient.account,
                 });
-                await publicClient.waitForTransactionReceipt({
-                    hash: approveHash,
-                });
+                await waitForViemTransactionWithRetry(publicClient, approveHash);
             }
             // Run a simulation first to surface any revert reason
             try {
@@ -1593,9 +1744,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                 chain: walletClient.chain,
                 account: walletClient.account,
             });
-            await publicClient.waitForTransactionReceipt({
-                hash,
-            });
+            await waitForViemTransactionWithRetry(publicClient, hash);
             return hash;
         }
         catch (error) {
@@ -1673,9 +1822,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                 chain: walletClient.chain,
                 account: walletClient.account,
             });
-            await publicClient.waitForTransactionReceipt({
-                hash,
-            });
+            await waitForViemTransactionWithRetry(publicClient, hash);
             return hash;
         }
         catch (error) {
@@ -1725,9 +1872,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                 chain: walletClient.chain,
                 account: walletClient.account,
             });
-            await publicClient.waitForTransactionReceipt({
-                hash,
-            });
+            await waitForViemTransactionWithRetry(publicClient, hash);
             return hash;
         }
         catch (error) {
@@ -1893,9 +2038,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                 chain: walletClient.chain,
                 account: walletClient.account,
             });
-            await publicClient.waitForTransactionReceipt({
-                hash,
-            });
+            await waitForViemTransactionWithRetry(publicClient, hash);
             return hash;
         }
         catch (error) {
@@ -1945,9 +2088,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                 chain: walletClient.chain,
                 account: walletClient.account,
             });
-            await publicClient.waitForTransactionReceipt({
-                hash,
-            });
+            await waitForViemTransactionWithRetry(publicClient, hash);
             return hash;
         }
         catch (error) {
@@ -3715,8 +3856,12 @@ exports.WalletsRouter = WalletsRouter;
 exports.allRegions = allRegions;
 exports.countries = countries;
 exports.getAddresses = getAddresses;
+exports.parseEthersError = parseEthersError;
+exports.parseViemError = parseViemError;
 exports.regionMetadata = regionMetadata;
 exports.usStates = usStates;
 exports.useForwarder = useForwarder;
 exports.useOffchainFractions = useOffchainFractions;
-//# sourceMappingURL=farms-router-Darq9ZsF.js.map
+exports.waitForEthersTransactionWithRetry = waitForEthersTransactionWithRetry;
+exports.waitForViemTransactionWithRetry = waitForViemTransactionWithRetry;
+//# sourceMappingURL=farms-router-CCva--xp.js.map