@glowlabs-org/utils 0.2.145 → 0.2.147

package/dist/cjs/index.js

@@ -15,7 +15,7 @@ var viem = require('viem');
 var merkletreejs = require('merkletreejs');
 var ethers = require('ethers');
 var Decimal = require('decimal.js');
-var farmsRouter = require('./farms-router-C8V_F0vY.js');
+var farmsRouter = require('./farms-router-Cg0-zSMT.js');
 
 const GENESIS_TIMESTAMP = 1700352000;
 

package/dist/cjs/utils/transaction-utils.d.ts

@@ -6,6 +6,7 @@ export interface TransactionRetryOptions {
     maxRetries?: number;
     timeoutMs?: number;
     enableLogging?: boolean;
+    pollIntervalMs?: number;
 }
 /**
  * Enhanced transaction receipt handler with retry logic for viem

package/dist/esm/browser.js

@@ -1,5 +1,5 @@
-import { T as TRANSFER_TYPES } from './farms-router-C_7Ys4An.js';
-export { C as ControlRouter, D as DECIMALS_BY_TOKEN, j as FORWARDER_ABI, F as FarmsRouter, e as ForwarderError, m as GCA_URLS, G as GLOW_WEIGHT_DECIMAL_PRECISION, H as HUB_URL, d as KICKSTARTER_STATUS, K as KickstarterRouter, M as MAX_WEIGHT, k as OFFCHAIN_FRACTIONS_ABI, O as OFF_CHAIN_PAYMENT_CURRENCIES, f as OffchainFractionsError, P as PAYMENT_CURRENCIES, b as REGIONS, R as RegionRouter, S as STAKING_DIRECTIONS, U as USDG_WEIGHT_DECIMAL_PRECISION, W as WalletsRouter, g as allRegions, c as configureSentry, i as countries, l as getAddresses, n as parseEthersError, p as parseViemError, r as regionMetadata, h as usStates, u as useForwarder, a as useOffchainFractions, o as waitForEthersTransactionWithRetry, w as waitForViemTransactionWithRetry } from './farms-router-C_7Ys4An.js';
+import { T as TRANSFER_TYPES } from './farms-router-PZUo1LyW.js';
+export { C as ControlRouter, D as DECIMALS_BY_TOKEN, j as FORWARDER_ABI, F as FarmsRouter, e as ForwarderError, m as GCA_URLS, G as GLOW_WEIGHT_DECIMAL_PRECISION, H as HUB_URL, d as KICKSTARTER_STATUS, K as KickstarterRouter, M as MAX_WEIGHT, k as OFFCHAIN_FRACTIONS_ABI, O as OFF_CHAIN_PAYMENT_CURRENCIES, f as OffchainFractionsError, P as PAYMENT_CURRENCIES, b as REGIONS, R as RegionRouter, S as STAKING_DIRECTIONS, U as USDG_WEIGHT_DECIMAL_PRECISION, W as WalletsRouter, g as allRegions, c as configureSentry, i as countries, l as getAddresses, n as parseEthersError, p as parseViemError, r as regionMetadata, h as usStates, u as useForwarder, a as useOffchainFractions, o as waitForEthersTransactionWithRetry, w as waitForViemTransactionWithRetry } from './farms-router-PZUo1LyW.js';
 import { verifyTypedData, checksumAddress } from 'viem';
 import 'ethers';
 

package/dist/esm/{farms-router-C_7Ys4An.js → farms-router-PZUo1LyW.js}

@@ -272,8 +272,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",
@@ -352,6 +352,7 @@ const DEFAULT_OPTIONS = {
     maxRetries: 3,
     timeoutMs: 60000,
     enableLogging: true,
+    pollIntervalMs: 2000,
 };
 /**
  * Enhanced transaction receipt handler with retry logic for viem
@@ -360,66 +361,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
@@ -428,82 +409,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;
@@ -723,7 +664,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) {
@@ -783,7 +727,10 @@ function useForwarder(signer, CHAIN_ID) {
             if (allowance < amount) {
                 try {
                     const approveTx = await tokenContract.approve(ADDRESSES.FORWARDER, MaxUint256);
-                    await waitForEthersTransactionWithRetry(signer, approveTx.hash);
+                    await waitForEthersTransactionWithRetry(signer, approveTx.hash, {
+                        timeoutMs: 30000,
+                        pollIntervalMs: 2000,
+                    });
                 }
                 catch (approveError) {
                     sentryCaptureException(approveError, {
@@ -854,7 +801,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) {
@@ -1089,7 +1039,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) {
@@ -4254,4 +4207,4 @@ function FarmsRouter(baseUrl) {
 }
 
 export { ControlRouter as C, DECIMALS_BY_TOKEN as D, FarmsRouter as F, GLOW_WEIGHT_DECIMAL_PRECISION as G, HUB_URL as H, KickstarterRouter as K, MAX_WEIGHT as M, OFF_CHAIN_PAYMENT_CURRENCIES as O, PAYMENT_CURRENCIES as P, RegionRouter as R, STAKING_DIRECTIONS as S, TRANSFER_TYPES as T, USDG_WEIGHT_DECIMAL_PRECISION as U, WalletsRouter as W, useOffchainFractions as a, REGIONS as b, configureSentry as c, KICKSTARTER_STATUS as d, ForwarderError as e, OffchainFractionsError as f, allRegions as g, usStates as h, countries as i, FORWARDER_ABI as j, OFFCHAIN_FRACTIONS_ABI as k, getAddresses as l, GCA_URLS as m, parseEthersError as n, waitForEthersTransactionWithRetry as o, parseViemError as p, regionMetadata as r, useForwarder as u, waitForViemTransactionWithRetry as w };
-//# sourceMappingURL=farms-router-C_7Ys4An.js.map
+//# sourceMappingURL=farms-router-PZUo1LyW.js.map