@glowlabs-org/utils 0.2.145 → 0.2.147

package/dist/esm/index.js

@@ -13,8 +13,8 @@ import { parseUnits, formatUnits } from 'viem';
 import { MerkleTree } from 'merkletreejs';
 import { solidityPackedKeccak256, keccak256 } from 'ethers';
 import Decimal from 'decimal.js';
-import { H as HUB_URL, U as USDG_WEIGHT_DECIMAL_PRECISION, G as GLOW_WEIGHT_DECIMAL_PRECISION, M as MAX_WEIGHT } from './farms-router-C_7Ys4An.js';
-export { C as ControlRouter, F as FarmsRouter, d as KICKSTARTER_STATUS, K as KickstarterRouter, O as OFF_CHAIN_PAYMENT_CURRENCIES, P as PAYMENT_CURRENCIES, b as REGIONS, R as RegionRouter, S as STAKING_DIRECTIONS, T as TRANSFER_TYPES, W as WalletsRouter, c as configureSentry, u as useForwarder, a as useOffchainFractions } from './farms-router-C_7Ys4An.js';
+import { H as HUB_URL, U as USDG_WEIGHT_DECIMAL_PRECISION, G as GLOW_WEIGHT_DECIMAL_PRECISION, M as MAX_WEIGHT } from './farms-router-PZUo1LyW.js';
+export { C as ControlRouter, F as FarmsRouter, d as KICKSTARTER_STATUS, K as KickstarterRouter, O as OFF_CHAIN_PAYMENT_CURRENCIES, P as PAYMENT_CURRENCIES, b as REGIONS, R as RegionRouter, S as STAKING_DIRECTIONS, T as TRANSFER_TYPES, W as WalletsRouter, c as configureSentry, u as useForwarder, a as useOffchainFractions } from './farms-router-PZUo1LyW.js';
 
 const GENESIS_TIMESTAMP = 1700352000;
 

package/dist/esm/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glowlabs-org/utils",
-  "version": "0.2.145",
+  "version": "0.2.147",
   "description": "A library containing all typechain types and addresses relating to the glow guarded launch",
   "keywords": [],
   "author": "",

package/src/constants/addresses.ts

@@ -47,8 +47,8 @@ const sepoliaAddresses: Record<ContractKeys, `0x${string}`> = {
   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",

package/src/lib/hooks/use-forwarder.ts

@@ -235,7 +235,10 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
         ADDRESSES.FORWARDER,
         amount
       );
-      await waitForEthersTransactionWithRetry(signer, approveTx.hash);
+      await waitForEthersTransactionWithRetry(signer, approveTx.hash, {
+        timeoutMs: 30000,
+        pollIntervalMs: 2000,
+      });
 
       return true;
     } catch (error) {
@@ -311,7 +314,10 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
             ADDRESSES.FORWARDER,
             MaxUint256
           );
-          await waitForEthersTransactionWithRetry(signer, approveTx.hash);
+          await waitForEthersTransactionWithRetry(signer, approveTx.hash, {
+            timeoutMs: 30000,
+            pollIntervalMs: 2000,
+          });
         } catch (approveError) {
           sentryCaptureException(approveError, {
             action: "forwardTokens.approve",
@@ -409,7 +415,10 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
           message
         );
       }
-      await waitForEthersTransactionWithRetry(signer, tx.hash);
+      await waitForEthersTransactionWithRetry(signer, tx.hash, {
+        timeoutMs: 30000,
+        pollIntervalMs: 2000,
+      });
 
       return tx.hash;
     } catch (txError: any) {
@@ -745,7 +754,10 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
 
       // 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: any) {

package/src/utils/transaction-utils.ts

@@ -56,12 +56,14 @@ export interface TransactionRetryOptions {
   maxRetries?: number;
   timeoutMs?: number;
   enableLogging?: boolean;
+  pollIntervalMs?: number;
 }
 
 const DEFAULT_OPTIONS: Required<TransactionRetryOptions> = {
   maxRetries: 3,
   timeoutMs: 60000,
   enableLogging: true,
+  pollIntervalMs: 2000,
 };
 
 /**
@@ -75,90 +77,57 @@ export async function waitForViemTransactionWithRetry(
   hash: `0x${string}`,
   options: TransactionRetryOptions = {}
 ): Promise<void> {
-  const { maxRetries, timeoutMs, enableLogging } = {
+  const { maxRetries, timeoutMs, enableLogging, pollIntervalMs } = {
     ...DEFAULT_OPTIONS,
     ...options,
   };
 
-  let lastError: Error | null = null;
+  const deadline = Date.now() + timeoutMs;
+  let consecutiveErrors = 0;
 
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+  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 as Error;
-
-      // Check if it's a timeout or not found error
       const errorMessage = parseViemError(error);
-      const isRetryableError =
+      // 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("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...`
+        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)}`
+            `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`);
 }
 
 /**
@@ -172,114 +141,52 @@ export async function waitForEthersTransactionWithRetry(
   txHash: string,
   options: TransactionRetryOptions = {}
 ): Promise<void> {
-  const { maxRetries, timeoutMs, enableLogging } = {
+  const { maxRetries, timeoutMs, enableLogging, pollIntervalMs } = {
     ...DEFAULT_OPTIONS,
     ...options,
   };
 
-  let lastError: Error | null = 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");
-      }
+  const provider = signer.provider;
+  if (!provider) {
+    throw new Error("Provider not available");
+  }
 
-      // Check transaction status (ethers.js uses status: 0 for failed, 1 for success)
-      if ((receipt as any).status === 0) {
-        throw new Error(`Transaction ${txHash} was reverted on-chain`);
-      }
+  const deadline = Date.now() + timeoutMs;
+  let consecutiveErrors = 0;
 
-      if (enableLogging) {
-        console.log(
-          `Transaction ${txHash} confirmed successfully in block ${
-            (receipt as any).blockNumber
-          }`
-        );
+  while (Date.now() < deadline) {
+    try {
+      const receipt = await provider.getTransactionReceipt(txHash);
+      if (receipt) {
+        if ((receipt as any).status === 0) {
+          throw new Error(`Transaction ${txHash} was reverted on-chain`);
+        }
+        if (enableLogging) {
+          console.log(
+            `Transaction ${txHash} confirmed successfully in block ${
+              (receipt as any).blockNumber
+            }`
+          );
+        }
+        return;
       }
-      return; // Success, exit the function
     } catch (error) {
-      lastError = error as 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
+      consecutiveErrors++;
+      if (consecutiveErrors >= maxRetries) {
         throw new Error(
-          `Transaction failed after ${attempt} attempts: ${errorMessage}`
+          `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...`
+          `Error fetching receipt (attempt ${consecutiveErrors}/${maxRetries}), retrying in ${pollIntervalMs}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
-      }
     }
+
+    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`);
 }