@glowlabs-org/utils 0.2.140 → 0.2.142

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-B5g58fsT.js';
-export { C as ControlRouter, F as FarmsRouter, c 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, u as useForwarder, a as useOffchainFractions } from './farms-router-B5g58fsT.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-Cxbn5Hap.js';
+export { C as ControlRouter, F as FarmsRouter, c 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, u as useForwarder, a as useOffchainFractions } from './farms-router-Cxbn5Hap.js';
 
 const GENESIS_TIMESTAMP = 1700352000;
 

package/dist/esm/lib/types/index.d.ts

@@ -370,6 +370,7 @@ export interface GlwRegionRewardsResponse {
 export interface ControlWallet {
     address: string;
     controlBalance: string;
+    committedControl: string;
     stakedControl: string;
     createdAt: string;
 }
@@ -409,11 +410,11 @@ export interface WalletFarmInfo {
 export interface WalletDetails {
     wallet: string;
     controlBalance: string;
+    committedControl: string;
     stakedControl: string;
     createdAt: string;
     regions: WalletRegionStakeTotal[];
     ownedFarms: WalletFarmInfo[];
-    purchasedFarms: WalletFarmInfo[];
 }
 export interface EstimateRewardScoreParams {
     userId: string;

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

@@ -0,0 +1,23 @@
+import { type PublicClient } from "viem";
+import { type Signer } from "ethers";
+export declare function parseViemError(error: unknown): string;
+export declare function parseEthersError(error: unknown): string;
+export interface TransactionRetryOptions {
+    maxRetries?: number;
+    timeoutMs?: number;
+    enableLogging?: boolean;
+}
+/**
+ * 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
+ */
+export declare function waitForViemTransactionWithRetry(publicClient: PublicClient, hash: `0x${string}`, options?: TransactionRetryOptions): Promise<void>;
+/**
+ * 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
+ */
+export declare function waitForEthersTransactionWithRetry(signer: Signer, txHash: string, options?: TransactionRetryOptions): Promise<void>;

package/package.json

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

package/src/browser.ts

@@ -13,3 +13,4 @@ export * from "./constants/addresses";
 export * from "./constants/weights";
 export * from "./constants/urls";
 export * from "./utils/stake-control";
+export * from "./utils/transaction-utils";

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

@@ -4,6 +4,10 @@ import { ERC20_ABI } from "../abis/erc20.abi";
 import { getAddresses } from "../../constants/addresses";
 import { formatEther } from "viem";
 import { PendingTransferType, TRANSFER_TYPES } from "../types";
+import {
+  parseEthersError,
+  waitForEthersTransactionWithRetry,
+} from "../../utils/transaction-utils";
 
 export enum ForwarderError {
   CONTRACT_NOT_AVAILABLE = "Contract not available",
@@ -31,32 +35,6 @@ export interface ForwardParams {
   kickstarterId?: string;
 }
 
-// Utility to extract the most useful revert reason from an ethers error object
-function parseEthersError(error: unknown): string {
-  if (!error) return "Unknown error";
-  const possibleError: any = error;
-
-  // If the error originates from a callStatic it will often be found at `error?.error?.body`
-  if (possibleError?.error?.body) {
-    try {
-      const body = JSON.parse(possibleError.error.body);
-      // Hardhat style errors
-      if (body?.error?.message) return body.error.message as string;
-    } catch {}
-  }
-
-  // Found on MetaMask/Alchemy shape errors
-  if (possibleError?.data?.message) return possibleError.data.message as string;
-  if (possibleError?.error?.message)
-    return possibleError.error.message as string;
-
-  // Standard ethers v5 message
-  if (possibleError?.reason) return possibleError.reason as string;
-  if (possibleError?.message) return possibleError.message as string;
-
-  return ForwarderError.UNKNOWN_ERROR;
-}
-
 // Type-guard style helper to ensure a signer exists throughout the rest of the function.
 function assertSigner(
   maybeSigner: Signer | undefined
@@ -253,7 +231,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
         ADDRESSES.FORWARDER,
         amount
       );
-      await approveTx.wait();
+      await waitForEthersTransactionWithRetry(signer, approveTx.hash);
 
       return true;
     } catch (error) {
@@ -312,7 +290,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
             ADDRESSES.FORWARDER,
             MaxUint256
           );
-          await approveTx.wait();
+          await waitForEthersTransactionWithRetry(signer, approveTx.hash);
         } catch (approveError) {
           throw new Error(
             parseEthersError(approveError) || "Token approval failed"
@@ -391,7 +369,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
           message
         );
       }
-      await tx.wait();
+      await waitForEthersTransactionWithRetry(signer, tx.hash);
 
       return tx.hash;
     } catch (txError: any) {
@@ -715,7 +693,7 @@ 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 tx.wait();
+      await waitForEthersTransactionWithRetry(signer, tx.hash);
 
       return tx.hash;
     } catch (error: any) {

package/src/lib/hooks/use-offchain-fractions.ts

@@ -7,6 +7,10 @@ import {
 import { OFFCHAIN_FRACTIONS_ABI } from "../abis/offchainFractions";
 import { ERC20_ABI } from "../abis/erc20.abi";
 import { getAddresses } from "../../constants/addresses";
+import {
+  parseViemError,
+  waitForViemTransactionWithRetry,
+} from "../../utils/transaction-utils";
 
 export enum OffchainFractionsError {
   CONTRACT_NOT_AVAILABLE = "Contract not available",
@@ -63,31 +67,6 @@ export interface RefundDetails {
   useCounterfactualAddress: boolean;
 }
 
-// Utility to extract the most useful revert reason from a viem error object
-function parseViemError(error: unknown): string {
-  if (!error) return "Unknown error";
-
-  // Check if it's a viem BaseError
-  if (error instanceof Error) {
-    // For contract revert errors
-    if ((error as any).cause?.reason) {
-      return (error as any).cause.reason;
-    }
-
-    // For viem's shortMessage
-    if ((error as any).shortMessage) {
-      return (error as any).shortMessage;
-    }
-
-    // Fallback to regular message
-    if (error.message) {
-      return error.message;
-    }
-  }
-
-  return OffchainFractionsError.UNKNOWN_ERROR;
-}
-
 // Type-guard style helper to ensure a wallet client exists throughout the rest of the function.
 function assertWalletClient(
   maybeWalletClient: WalletClient | undefined
@@ -195,9 +174,7 @@ export function useOffchainFractions(
         account: walletClient.account!,
       });
 
-      await publicClient.waitForTransactionReceipt({
-        hash,
-      });
+      await waitForViemTransactionWithRetry(publicClient, hash);
 
       return true;
     } catch (error) {
@@ -286,9 +263,7 @@ export function useOffchainFractions(
         account: walletClient.account!,
       });
 
-      await publicClient.waitForTransactionReceipt({
-        hash,
-      });
+      await waitForViemTransactionWithRetry(publicClient, hash);
 
       return hash;
     } catch (error) {
@@ -358,9 +333,7 @@ export function useOffchainFractions(
           chain: walletClient.chain,
           account: walletClient.account!,
         });
-        await publicClient.waitForTransactionReceipt({
-          hash: approveHash,
-        });
+        await waitForViemTransactionWithRetry(publicClient, approveHash);
       }
 
       // Run a simulation first to surface any revert reason
@@ -402,9 +375,7 @@ export function useOffchainFractions(
         account: walletClient.account!,
       });
 
-      await publicClient.waitForTransactionReceipt({
-        hash,
-      });
+      await waitForViemTransactionWithRetry(publicClient, hash);
 
       return hash;
     } catch (error) {
@@ -495,9 +466,7 @@ export function useOffchainFractions(
         account: walletClient.account!,
       });
 
-      await publicClient.waitForTransactionReceipt({
-        hash,
-      });
+      await waitForViemTransactionWithRetry(publicClient, hash);
 
       return hash;
     } catch (error) {
@@ -552,9 +521,7 @@ export function useOffchainFractions(
         account: walletClient.account!,
       });
 
-      await publicClient.waitForTransactionReceipt({
-        hash,
-      });
+      await waitForViemTransactionWithRetry(publicClient, hash);
 
       return hash;
     } catch (error) {
@@ -748,9 +715,7 @@ export function useOffchainFractions(
         account: walletClient.account!,
       });
 
-      await publicClient.waitForTransactionReceipt({
-        hash,
-      });
+      await waitForViemTransactionWithRetry(publicClient, hash);
 
       return hash;
     } catch (error) {
@@ -808,9 +773,7 @@ export function useOffchainFractions(
         account: walletClient.account!,
       });
 
-      await publicClient.waitForTransactionReceipt({
-        hash,
-      });
+      await waitForViemTransactionWithRetry(publicClient, hash);
 
       return hash;
     } catch (error) {

package/src/lib/types/index.ts

@@ -455,6 +455,7 @@ export interface GlwRegionRewardsResponse {
 export interface ControlWallet {
   address: string;
   controlBalance: string;
+  committedControl: string;
   stakedControl: string;
   createdAt: string; // ISO 8601
 }
@@ -499,11 +500,11 @@ export interface WalletFarmInfo {
 export interface WalletDetails {
   wallet: string;
   controlBalance: string;
+  committedControl: string;
   stakedControl: string;
   createdAt: string; // ISO 8601
   regions: WalletRegionStakeTotal[];
   ownedFarms: WalletFarmInfo[];
-  purchasedFarms: WalletFarmInfo[];
 }
 
 // ----------------------------- Farms Reward Score ---------------------------

package/src/utils/transaction-utils.ts

@@ -0,0 +1,285 @@
+import { type PublicClient } from "viem";
+import { type Signer } from "ethers";
+
+// Error parsing utilities
+export function parseViemError(error: unknown): string {
+  if (!error) return "Unknown error";
+
+  // Check if it's a viem BaseError
+  if (error instanceof Error) {
+    // For contract revert errors
+    if ((error as any).cause?.reason) {
+      return (error as any).cause.reason;
+    }
+
+    // For viem's shortMessage
+    if ((error as any).shortMessage) {
+      return (error as any).shortMessage;
+    }
+
+    // Fallback to regular message
+    if (error.message) {
+      return error.message;
+    }
+  }
+
+  return "Unknown error";
+}
+
+export function parseEthersError(error: unknown): string {
+  if (!error) return "Unknown error";
+  const possibleError: any = error;
+
+  // If the error originates from a callStatic it will often be found at `error?.error?.body`
+  if (possibleError?.error?.body) {
+    try {
+      const body = JSON.parse(possibleError.error.body);
+      // Hardhat style errors
+      if (body?.error?.message) return body.error.message as string;
+    } catch {}
+  }
+
+  // Found on MetaMask/Alchemy shape errors
+  if (possibleError?.data?.message) return possibleError.data.message as string;
+  if (possibleError?.error?.message)
+    return possibleError.error.message as string;
+
+  // Standard ethers v5 message
+  if (possibleError?.reason) return possibleError.reason as string;
+  if (possibleError?.message) return possibleError.message as string;
+
+  return "Unknown error";
+}
+
+// Transaction receipt utilities
+export interface TransactionRetryOptions {
+  maxRetries?: number;
+  timeoutMs?: number;
+  enableLogging?: boolean;
+}
+
+const DEFAULT_OPTIONS: Required<TransactionRetryOptions> = {
+  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
+ */
+export async function waitForViemTransactionWithRetry(
+  publicClient: PublicClient,
+  hash: `0x${string}`,
+  options: TransactionRetryOptions = {}
+): Promise<void> {
+  const { maxRetries, timeoutMs, enableLogging } = {
+    ...DEFAULT_OPTIONS,
+    ...options,
+  };
+
+  let lastError: Error | null = 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 as 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
+ */
+export async function waitForEthersTransactionWithRetry(
+  signer: Signer,
+  txHash: string,
+  options: TransactionRetryOptions = {}
+): Promise<void> {
+  const { maxRetries, timeoutMs, enableLogging } = {
+    ...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");
+      }
+
+      // 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`);
+      }
+
+      if (enableLogging) {
+        console.log(
+          `Transaction ${txHash} confirmed successfully in block ${
+            (receipt as any).blockNumber
+          }`
+        );
+      }
+      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
+        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
+    )}`
+  );
+}