@glowlabs-org/utils 0.2.173 → 0.2.175

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 './calculate-farm-efficiency-DbFNiaxO.js';
-export { C as ControlRouter, F as FarmsRouter, e as KICKSTARTER_STATUS, K as KickstarterRouter, O as OFF_CHAIN_PAYMENT_CURRENCIES, P as PAYMENT_CURRENCIES, d as REGIONS, R as RegionRouter, S as STAKING_DIRECTIONS, T as TRANSFER_TYPES, W as WalletsRouter, f as calculateFarmEfficiency, c as configureSentry, u as useForwarder, a as useOffchainFractions, b as useRewardsKernel } from './calculate-farm-efficiency-DbFNiaxO.js';
+import { H as HUB_URL, U as USDG_WEIGHT_DECIMAL_PRECISION, G as GLOW_WEIGHT_DECIMAL_PRECISION, M as MAX_WEIGHT } from './calculate-farm-efficiency-DvqnF04d.js';
+export { C as ControlRouter, F as FarmsRouter, e as KICKSTARTER_STATUS, K as KickstarterRouter, O as OFF_CHAIN_PAYMENT_CURRENCIES, P as PAYMENT_CURRENCIES, d as REGIONS, R as RegionRouter, S as STAKING_DIRECTIONS, T as TRANSFER_TYPES, W as WalletsRouter, f as calculateFarmEfficiency, c as configureSentry, u as useForwarder, a as useOffchainFractions, b as useRewardsKernel } from './calculate-farm-efficiency-DvqnF04d.js';
 
 const GENESIS_TIMESTAMP = 1700352000;
 

package/dist/esm/lib/hooks/use-forwarder.d.ts

@@ -1,4 +1,5 @@
 import { type Signer } from "ethers";
+import { type PublicClient, type WalletClient } from "viem";
 import { PendingTransferType } from "../types";
 export declare enum ForwarderError {
     CONTRACT_NOT_AVAILABLE = "Contract not available",
@@ -19,7 +20,7 @@ export interface ForwardParams {
     regionId?: number;
     kickstarterId?: string;
 }
-export declare function useForwarder(signer: Signer | undefined, CHAIN_ID: number): {
+export declare function useForwarder(signer: Signer | undefined, CHAIN_ID: number, publicClient?: PublicClient, walletClient?: WalletClient): {
     forwardTokens: (params: ForwardParams) => Promise<string>;
     payProtocolFeeAndMintGCTLAndStake: (amount: bigint, userAddress: string, applicationId: string, regionId?: number, currency?: Currency) => Promise<string>;
     sponsorProtocolFeeAndMintGCTLAndStake: (amount: bigint, userAddress: string, applicationId: string, currency?: Currency) => Promise<string>;

package/package.json

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

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

@@ -2,11 +2,18 @@ import { Contract, MaxUint256, type Signer } from "ethers";
 import { FORWARDER_ABI } from "../abis/forwarderABI";
 import { ERC20_ABI } from "../abis/erc20.abi";
 import { getAddresses } from "../../constants/addresses";
-import { formatEther } from "viem";
+import {
+  type PublicClient,
+  type WalletClient,
+  type Address,
+  formatEther,
+} from "viem";
 import { PendingTransferType, TRANSFER_TYPES } from "../types";
 import {
   parseEthersError,
+  parseViemError,
   waitForEthersTransactionWithRetry,
+  waitForViemTransactionWithRetry,
 } from "../../utils/transaction-utils";
 import {
   sentryAddBreadcrumb,
@@ -48,7 +55,24 @@ function assertSigner(
   }
 }
 
-export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
+// Type-guard style helper to ensure a wallet client exists throughout the rest of the function.
+function assertWalletClient(
+  maybeWalletClient: WalletClient | undefined
+): asserts maybeWalletClient is WalletClient {
+  if (!maybeWalletClient) {
+    throw new Error(ForwarderError.SIGNER_NOT_AVAILABLE);
+  }
+  if (!maybeWalletClient.account) {
+    throw new Error("Wallet client must have an account");
+  }
+}
+
+export function useForwarder(
+  signer: Signer | undefined,
+  CHAIN_ID: number,
+  publicClient?: PublicClient,
+  walletClient?: WalletClient
+) {
   // Use dynamic addresses based on chain configuration
   const ADDRESSES = getAddresses(CHAIN_ID);
 
@@ -58,7 +82,16 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     isProcessing = value;
   };
 
-  // Returns a contract instance for Forwarder
+  // Helper to assert public client is available
+  function assertPublicClient(
+    maybePublicClient: PublicClient | undefined
+  ): asserts maybePublicClient is PublicClient {
+    if (!maybePublicClient) {
+      throw new Error("Public client not available");
+    }
+  }
+
+  // Returns a contract instance for Forwarder (Legacy Ethers)
   function getForwarderContract() {
     assertSigner(signer);
     return new Contract(ADDRESSES.FORWARDER, FORWARDER_ABI, signer);
@@ -221,27 +254,64 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     amount: bigint,
     currency: Currency = "USDC"
   ): Promise<boolean> {
-    assertSigner(signer);
-
     try {
-      const tokenContract = getTokenContract(currency);
-      if (!tokenContract)
-        throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
-
       setIsProcessing(true);
 
-      // Approve only the specific amount needed
-      const approveTx = await tokenContract.approve(
-        ADDRESSES.FORWARDER,
-        amount
-      );
-      await waitForEthersTransactionWithRetry(signer, approveTx.hash, {
-        timeoutMs: 60000,
-        pollIntervalMs: 2000,
-      });
+      // Get token address
+      let tokenAddress: string;
+      switch (currency) {
+        case "USDC":
+          tokenAddress = ADDRESSES.USDC;
+          break;
+        case "GLW":
+          tokenAddress = ADDRESSES.GLW;
+          break;
+        case "USDG":
+          tokenAddress = ADDRESSES.USDG;
+          break;
+        default:
+          throw new Error(
+            `Currency ${currency} not yet supported. Only USDC, GLW, and USDG are currently supported.`
+          );
+      }
+
+      // If walletClient and publicClient are available, use Viem (better for mobile)
+      if (walletClient && publicClient) {
+        assertWalletClient(walletClient);
+        assertPublicClient(publicClient);
+
+        const hash = await walletClient.writeContract({
+          address: tokenAddress as Address,
+          abi: ERC20_ABI,
+          functionName: "approve",
+          args: [ADDRESSES.FORWARDER as Address, amount],
+          chain: walletClient.chain,
+          account: walletClient.account!,
+        });
+
+        await waitForViemTransactionWithRetry(publicClient, hash);
+      } else {
+        // Fallback to Ethers
+        assertSigner(signer);
+        const tokenContract = getTokenContract(currency);
+        if (!tokenContract)
+          throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+
+        const approveTx = await tokenContract.approve(
+          ADDRESSES.FORWARDER,
+          amount
+        );
+        await waitForEthersTransactionWithRetry(signer, approveTx.hash, {
+          timeoutMs: 60000,
+          pollIntervalMs: 2000,
+        });
+      }
 
       return true;
     } catch (error) {
+      if (walletClient && publicClient) {
+        throw new Error(parseViemError(error));
+      }
       throw new Error(parseEthersError(error));
     } finally {
       setIsProcessing(false);
@@ -253,19 +323,10 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
    * @param params Forward parameters including type, amount, and required fields
    */
   async function forwardTokens(params: ForwardParams): Promise<string> {
-    assertSigner(signer);
-
     try {
-      const forwarderContract = getForwarderContract();
-      if (!forwarderContract)
-        throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
-
       setIsProcessing(true);
 
       const { amount, currency = "USDC" } = params;
-      const tokenContract = getTokenContract(currency);
-      if (!tokenContract)
-        throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
 
       sentryAddBreadcrumb({
         category: "forwarder",
@@ -284,55 +345,19 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
         },
       });
 
-      const owner = await signer.getAddress();
-
-      // Construct the appropriate message for this forward type
-      const message = constructForwardMessage(params);
-
-      // Special handling: PayAuditFees can ONLY be USDC, and must call forward()
+      // Special handling checks
       const isAuditFees = params.type === TRANSFER_TYPES.PayAuditFees;
       if (isAuditFees && currency !== "USDC") {
         throw new Error("PayAuditFees only supports USDC");
       }
 
-      // CommitKickstarter supports only USDC or USDG (GLW not allowed)
       const isCommitKickstarter =
         params.type === TRANSFER_TYPES.CommitKickstarter;
       if (isCommitKickstarter && currency === "GLW") {
         throw new Error("CommitKickstarter supports only USDC or USDG");
       }
 
-      // Check allowance and approve if necessary
-      const allowance: bigint = await tokenContract.allowance(
-        owner,
-        ADDRESSES.FORWARDER
-      );
-      console.log("allowance", allowance.toString());
-      if (allowance < amount) {
-        try {
-          const approveTx = await tokenContract.approve(
-            ADDRESSES.FORWARDER,
-            MaxUint256
-          );
-          await waitForEthersTransactionWithRetry(signer, approveTx.hash, {
-            timeoutMs: 60000,
-            pollIntervalMs: 2000,
-          });
-        } catch (approveError) {
-          sentryCaptureException(approveError, {
-            action: "forwardTokens.approve",
-            chainId: CHAIN_ID,
-            spender: ADDRESSES.FORWARDER,
-            amount: MaxUint256.toString(),
-            currency,
-          });
-          throw new Error(
-            parseEthersError(approveError) || "Token approval failed"
-          );
-        }
-      }
-
-      // Get the token address based on currency
+      // Get token address
       let tokenAddress: string;
       switch (currency) {
         case "USDC":
@@ -348,27 +373,192 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
           throw new Error(`Unsupported currency for forwarding: ${currency}`);
       }
 
-      // Determine sendToCounterfactualWallet: false for audit fees (paid in USDC directly)
+      const message = constructForwardMessage(params);
       const sendToCounterfactualWallet = !isAuditFees;
 
-      // Run a static call first to surface any revert reason (ethers v6)
-      try {
+      // Handle transaction based on available client
+      if (walletClient && publicClient) {
+        // --- VIEM IMPLEMENTATION ---
+        assertWalletClient(walletClient);
+        assertPublicClient(publicClient);
+
+        const owner = walletClient.account!.address;
+
+        // Check allowance
+        const allowance = (await publicClient.readContract({
+          address: tokenAddress as Address,
+          abi: ERC20_ABI,
+          functionName: "allowance",
+          args: [owner as Address, ADDRESSES.FORWARDER as Address],
+        })) as bigint;
+
+        if (allowance < amount) {
+          try {
+            const approveHash = await walletClient.writeContract({
+              address: tokenAddress as Address,
+              abi: ERC20_ABI,
+              functionName: "approve",
+              args: [ADDRESSES.FORWARDER as Address, MaxUint256],
+              chain: walletClient.chain,
+              account: walletClient.account!,
+            });
+            await waitForViemTransactionWithRetry(publicClient, approveHash);
+          } catch (approveError) {
+            sentryCaptureException(approveError, {
+              action: "forwardTokens.approve",
+              chainId: CHAIN_ID,
+              spender: ADDRESSES.FORWARDER,
+              amount: MaxUint256.toString(),
+              currency,
+            });
+            throw new Error(
+              parseViemError(approveError) || "Token approval failed"
+            );
+          }
+        }
+
+        // Simulate
+        try {
+          if (!isAuditFees && currency === "USDC") {
+            await publicClient.simulateContract({
+              address: ADDRESSES.FORWARDER as Address,
+              abi: FORWARDER_ABI,
+              functionName: "swapUSDCAndForwardUSDG",
+              args: [
+                amount,
+                ADDRESSES.FOUNDATION_WALLET as Address,
+                sendToCounterfactualWallet,
+                message,
+              ],
+              account: walletClient.account!,
+            });
+          } else {
+            await publicClient.simulateContract({
+              address: ADDRESSES.FORWARDER as Address,
+              abi: FORWARDER_ABI,
+              functionName: "forward",
+              args: [
+                tokenAddress as Address,
+                (isAuditFees
+                  ? ADDRESSES.AUDIT_FEE_WALLET
+                  : ADDRESSES.FOUNDATION_WALLET) as Address,
+                amount,
+                sendToCounterfactualWallet,
+                message,
+              ],
+              account: walletClient.account!,
+            });
+          }
+        } catch (staticError) {
+          sentryCaptureException(staticError, {
+            action: "forwardTokens.simulate",
+            chainId: CHAIN_ID,
+            function:
+              !isAuditFees && currency === "USDC"
+                ? "swapUSDCAndForwardUSDG"
+                : "forward",
+            tokenAddress,
+            amount: amount.toString(),
+            currency,
+            isAuditFees,
+          });
+          throw new Error(parseViemError(staticError));
+        }
+
+        // Write
+        let hash;
         if (!isAuditFees && currency === "USDC") {
-          await forwarderContract
-            .getFunction("swapUSDCAndForwardUSDG")
-            .staticCall(
+          hash = await walletClient.writeContract({
+            address: ADDRESSES.FORWARDER as Address,
+            abi: FORWARDER_ABI,
+            functionName: "swapUSDCAndForwardUSDG",
+            args: [
               amount,
-              ADDRESSES.FOUNDATION_WALLET,
+              ADDRESSES.FOUNDATION_WALLET as Address,
               sendToCounterfactualWallet,
               message,
-              {
-                from: owner,
-              }
-            );
+            ],
+            chain: walletClient.chain,
+            account: walletClient.account!,
+          });
         } else {
-          await forwarderContract
-            .getFunction("forward")
-            .staticCall(
+          hash = await walletClient.writeContract({
+            address: ADDRESSES.FORWARDER as Address,
+            abi: FORWARDER_ABI,
+            functionName: "forward",
+            args: [
+              tokenAddress as Address,
+              (isAuditFees
+                ? ADDRESSES.AUDIT_FEE_WALLET
+                : ADDRESSES.FOUNDATION_WALLET) as Address,
+              amount,
+              sendToCounterfactualWallet,
+              message,
+            ],
+            chain: walletClient.chain,
+            account: walletClient.account!,
+          });
+        }
+
+        await waitForViemTransactionWithRetry(publicClient, hash);
+        return hash;
+      } else {
+        // --- ETHERS IMPLEMENTATION (Legacy) ---
+        assertSigner(signer);
+        const forwarderContract = getForwarderContract();
+        if (!forwarderContract)
+          throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+
+        const tokenContract = getTokenContract(currency);
+        if (!tokenContract)
+          throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+
+        const owner = await signer.getAddress();
+
+        // Check allowance
+        const allowance: bigint = await tokenContract.allowance(
+          owner,
+          ADDRESSES.FORWARDER
+        );
+
+        if (allowance < amount) {
+          try {
+            const approveTx = await tokenContract.approve(
+              ADDRESSES.FORWARDER,
+              MaxUint256
+            );
+            await waitForEthersTransactionWithRetry(signer, approveTx.hash, {
+              timeoutMs: 60000,
+              pollIntervalMs: 2000,
+            });
+          } catch (approveError) {
+            sentryCaptureException(approveError, {
+              action: "forwardTokens.approve",
+              chainId: CHAIN_ID,
+              spender: ADDRESSES.FORWARDER,
+              amount: MaxUint256.toString(),
+              currency,
+            });
+            throw new Error(
+              parseEthersError(approveError) || "Token approval failed"
+            );
+          }
+        }
+
+        // Determine function and call static
+        try {
+          if (!isAuditFees && currency === "USDC") {
+            await forwarderContract
+              .getFunction("swapUSDCAndForwardUSDG")
+              .staticCall(
+                amount,
+                ADDRESSES.FOUNDATION_WALLET,
+                sendToCounterfactualWallet,
+                message,
+                { from: owner }
+              );
+          } else {
+            await forwarderContract.getFunction("forward").staticCall(
               tokenAddress,
               isAuditFees
                 ? ADDRESSES.AUDIT_FEE_WALLET
@@ -378,49 +568,51 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
               message,
               { from: owner }
             );
+          }
+        } catch (staticError) {
+          sentryCaptureException(staticError, {
+            action: "forwardTokens.staticCall",
+            chainId: CHAIN_ID,
+            function:
+              !isAuditFees && currency === "USDC"
+                ? "swapUSDCAndForwardUSDG"
+                : "forward",
+            tokenAddress,
+            amount: amount.toString(),
+            currency,
+            isAuditFees,
+          });
+          throw new Error(parseEthersError(staticError));
         }
-      } catch (staticError) {
-        sentryCaptureException(staticError, {
-          action: "forwardTokens.staticCall",
-          chainId: CHAIN_ID,
-          function:
-            !isAuditFees && currency === "USDC"
-              ? "swapUSDCAndForwardUSDG"
-              : "forward",
-          tokenAddress,
-          amount: amount.toString(),
-          currency,
-          isAuditFees,
+
+        // Execute transaction
+        let tx;
+        if (!isAuditFees && currency === "USDC") {
+          tx = await forwarderContract.getFunction("swapUSDCAndForwardUSDG")(
+            amount,
+            ADDRESSES.FOUNDATION_WALLET,
+            sendToCounterfactualWallet,
+            message
+          );
+        } else {
+          tx = await forwarderContract.getFunction("forward")(
+            tokenAddress,
+            isAuditFees
+              ? ADDRESSES.AUDIT_FEE_WALLET
+              : ADDRESSES.FOUNDATION_WALLET,
+            amount,
+            sendToCounterfactualWallet,
+            message
+          );
+        }
+
+        await waitForEthersTransactionWithRetry(signer, tx.hash, {
+          timeoutMs: 60000,
+          pollIntervalMs: 2000,
         });
-        throw new Error(parseEthersError(staticError));
-      }
 
-      // Execute the forward transaction
-      let tx;
-      if (!isAuditFees && currency === "USDC") {
-        tx = await forwarderContract.getFunction("swapUSDCAndForwardUSDG")(
-          amount,
-          ADDRESSES.FOUNDATION_WALLET,
-          sendToCounterfactualWallet,
-          message
-        );
-      } else {
-        tx = await forwarderContract.getFunction("forward")(
-          tokenAddress,
-          isAuditFees
-            ? ADDRESSES.AUDIT_FEE_WALLET
-            : ADDRESSES.FOUNDATION_WALLET,
-          amount,
-          sendToCounterfactualWallet,
-          message
-        );
+        return tx.hash;
       }
-      await waitForEthersTransactionWithRetry(signer, tx.hash, {
-        timeoutMs: 60000,
-        pollIntervalMs: 2000,
-      });
-
-      return tx.hash;
     } catch (txError: any) {
       sentryCaptureException(txError, {
         action: "forwardTokens",
@@ -434,6 +626,9 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
         kickstarterId: params.kickstarterId,
         userAddress: params.userAddress,
       });
+      if (walletClient && publicClient) {
+        throw new Error(parseViemError(txError));
+      }
       throw new Error(parseEthersError(txError));
     } finally {
       setIsProcessing(false);
@@ -511,6 +706,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
       type: TRANSFER_TYPES.PayProtocolFee,
       currency,
       applicationId,
+      regionId: undefined, // Fix missing argument
     });
   }
 
@@ -543,7 +739,9 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     regionId?: number,
     currency: Currency = "USDC"
   ): Promise<string> {
-    assertSigner(signer);
+    // If using WalletClient, we don't strictly need a signer here anymore for forwardTokens
+    // But other methods might still rely on it.
+    if (!walletClient) assertSigner(signer);
 
     // GCTL minting only supports USDC and USDG
     if (currency === "GLW") {
@@ -569,7 +767,7 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     userAddress: string,
     currency: Currency = "USDC"
   ): Promise<string> {
-    assertSigner(signer);
+    if (!walletClient) assertSigner(signer);
 
     // GCTL minting only supports USDC and USDG
     if (currency === "GLW") {
@@ -754,10 +952,22 @@ 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, {
-        timeoutMs: 60000,
-        pollIntervalMs: 2000,
-      });
+
+      if (publicClient) {
+        await waitForViemTransactionWithRetry(
+          publicClient,
+          tx.hash as `0x${string}`,
+          {
+            timeoutMs: 60000,
+            pollIntervalMs: 2000,
+          }
+        );
+      } else {
+        await waitForEthersTransactionWithRetry(signer, tx.hash, {
+          timeoutMs: 60000,
+          pollIntervalMs: 2000,
+        });
+      }
 
       return tx.hash;
     } catch (error: any) {
@@ -802,6 +1012,6 @@ export function useForwarder(signer: Signer | undefined, CHAIN_ID: number) {
     addresses: ADDRESSES,
 
     // Signer availability
-    isSignerAvailable: !!signer,
+    isSignerAvailable: !!signer || !!walletClient,
   };
 }

package/src/utils/transaction-utils.ts

@@ -172,16 +172,27 @@ export async function waitForEthersTransactionWithRetry(
       }
     } catch (error) {
       const errorMessage = parseEthersError(error);
-      consecutiveErrors++;
-      if (consecutiveErrors >= maxRetries) {
-        throw new Error(
-          `Transaction failed after ${consecutiveErrors} attempts: ${errorMessage}`
-        );
-      }
-      if (enableLogging) {
-        console.warn(
-          `Error fetching receipt (attempt ${consecutiveErrors}/${maxRetries}), retrying in ${pollIntervalMs}ms...`
-        );
+
+      // Treat not found/receipt missing as retryable without counting towards errors
+      const isNotFound =
+        errorMessage.toLowerCase().includes("not found") ||
+        errorMessage.toLowerCase().includes("could not be found") ||
+        errorMessage.toLowerCase().includes("receipt") ||
+        errorMessage.toLowerCase().includes("not confirmed") ||
+        errorMessage.toLowerCase().includes("transactionreceiptnotfound");
+
+      if (!isNotFound) {
+        consecutiveErrors++;
+        if (consecutiveErrors >= maxRetries) {
+          throw new Error(
+            `Transaction failed after ${consecutiveErrors} attempts: ${errorMessage}`
+          );
+        }
+        if (enableLogging) {
+          console.warn(
+            `Error fetching receipt (attempt ${consecutiveErrors}/${maxRetries}), retrying in ${pollIntervalMs}ms...`
+          );
+        }
       }
     }