thirdweb 5.102.4-nightly-283dc289fca1ad16a9296e610d293b73a7123709-20250602000433 → 5.102.4-nightly-3d1c321bd6f5783bdee43185deef88f91b325a23-20250604000438

package/src/analytics/track/helpers.ts

@@ -0,0 +1,49 @@
+/**
+ * @internal
+ */
+export function isInsufficientFundsError(error: Error | unknown): boolean {
+  if (!error) return false;
+
+  const errorMessage =
+    typeof error === "string"
+      ? error
+      : (error as Error)?.message ||
+        (error as { data?: { message?: string } })?.data?.message ||
+        "";
+
+  const message = errorMessage.toLowerCase();
+
+  // Common patterns for insufficient funds errors
+  return (
+    message.includes("insufficient funds") ||
+    message.includes("insufficient balance") ||
+    (message.includes("insufficient") &&
+      (message.includes("native") || message.includes("gas"))) ||
+    // Common error codes from various wallets/providers
+    (error as { code?: string | number })?.code === "INSUFFICIENT_FUNDS" ||
+    (error as { reason?: string })?.reason === "insufficient funds"
+  );
+}
+
+/**
+ * @internal
+ */
+export function getErrorDetails(error: Error | unknown): {
+  message: string;
+  code?: string | number;
+} {
+  if (!error) return { message: "Unknown error" };
+
+  const message =
+    typeof error === "string"
+      ? error
+      : (error as Error)?.message ||
+        (error as { data?: { message?: string } })?.data?.message ||
+        String(error);
+
+  const code =
+    (error as { code?: string | number })?.code ||
+    (error as { reason?: string })?.reason;
+
+  return { message, code };
+}

package/src/analytics/track/transaction.test.ts

@@ -2,7 +2,10 @@ import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
 import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
 import type { ThirdwebClient } from "../../client/client.js";
-import { trackTransaction } from "./transaction.js";
+import {
+  trackInsufficientFundsError,
+  trackTransaction,
+} from "./transaction.js";
 
 const server = setupServer(
   http.post("https://c.thirdweb.com/event", () => {
@@ -127,4 +130,110 @@ describe("transaction tracking", () => {
       "test-partner-id",
     );
   });
+
+  it("should track insufficient funds error with correct data", async () => {
+    const mockClient: ThirdwebClient = {
+      clientId: "test-client-id",
+      secretKey: undefined,
+    };
+
+    let requestBody: unknown;
+    server.use(
+      http.post("https://c.thirdweb.com/event", async (handler) => {
+        requestBody = await handler.request.json();
+        return HttpResponse.json({});
+      }),
+    );
+
+    const mockError = new Error("Insufficient funds for gas * price + value");
+
+    await trackInsufficientFundsError({
+      client: mockClient,
+      error: mockError,
+      walletAddress: "0x1234567890123456789012345678901234567890",
+      chainId: 1,
+      contractAddress: "0xcontract",
+      transactionValue: 1000000000000000000n,
+    });
+
+    expect(requestBody).toEqual({
+      source: "sdk",
+      action: "transaction:insufficient_funds",
+      clientId: "test-client-id",
+      chainId: 1,
+      walletAddress: "0x1234567890123456789012345678901234567890",
+      contractAddress: "0xcontract",
+      transactionValue: "1000000000000000000",
+      requiredAmount: undefined,
+      userBalance: undefined,
+      errorMessage: "Insufficient funds for gas * price + value",
+      errorCode: undefined,
+    });
+  });
+
+  it("should not throw an error if insufficient funds tracking request fails", async () => {
+    const mockClient: ThirdwebClient = {
+      clientId: "test-client-id",
+      secretKey: undefined,
+    };
+
+    server.use(
+      http.post("https://c.thirdweb.com/event", () => {
+        return HttpResponse.error();
+      }),
+    );
+
+    const mockError = new Error("insufficient funds");
+
+    expect(() =>
+      trackInsufficientFundsError({
+        client: mockClient,
+        error: mockError,
+        walletAddress: "0x1234567890123456789012345678901234567890",
+        chainId: 137,
+      }),
+    ).not.toThrowError();
+
+    // Wait for the asynchronous POST request to complete
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  });
+
+  it("should track insufficient funds error during transaction preparation", async () => {
+    const mockClient: ThirdwebClient = {
+      clientId: "test-client-id",
+      secretKey: undefined,
+    };
+
+    let requestBody: unknown;
+    server.use(
+      http.post("https://c.thirdweb.com/event", async (handler) => {
+        requestBody = await handler.request.json();
+        return HttpResponse.json({});
+      }),
+    );
+
+    const mockError = new Error("insufficient funds for gas");
+
+    await trackInsufficientFundsError({
+      client: mockClient,
+      error: mockError,
+      walletAddress: "0xabcdef1234567890abcdef1234567890abcdef12",
+      chainId: 42,
+      contractAddress: "0x0987654321098765432109876543210987654321",
+    });
+
+    expect(requestBody).toEqual({
+      source: "sdk",
+      action: "transaction:insufficient_funds",
+      clientId: "test-client-id",
+      chainId: 42,
+      walletAddress: "0xabcdef1234567890abcdef1234567890abcdef12",
+      contractAddress: "0x0987654321098765432109876543210987654321",
+      transactionValue: undefined,
+      requiredAmount: undefined,
+      userBalance: undefined,
+      errorMessage: "insufficient funds for gas",
+      errorCode: undefined,
+    });
+  });
 });

package/src/analytics/track/transaction.ts

@@ -2,6 +2,7 @@ import type { ThirdwebClient } from "../../client/client.js";
 import { stringify } from "../../utils/json.js";
 import type { Ecosystem } from "../../wallets/in-app/core/wallet/types.js";
 import type { WalletId } from "../../wallets/wallet-types.js";
+import { getErrorDetails } from "./helpers.js";
 import { track } from "./index.js";
 
 type TransactionEvent = {
@@ -55,3 +56,39 @@ function trackTransactionEvent(
     },
   });
 }
+
+/**
+ * @internal
+ */
+export async function trackInsufficientFundsError(args: {
+  client: ThirdwebClient;
+  ecosystem?: Ecosystem;
+  error: Error | unknown;
+  walletAddress?: string;
+  chainId?: number;
+  contractAddress?: string;
+  functionName?: string;
+  transactionValue?: bigint;
+  requiredAmount?: bigint;
+  userBalance?: bigint;
+}) {
+  const errorDetails = getErrorDetails(args.error);
+
+  return track({
+    client: args.client,
+    ecosystem: args.ecosystem,
+    data: {
+      action: "transaction:insufficient_funds",
+      clientId: args.client.clientId,
+      chainId: args.chainId,
+      walletAddress: args.walletAddress,
+      contractAddress: args.contractAddress,
+      functionName: args.functionName,
+      transactionValue: args.transactionValue?.toString(),
+      requiredAmount: args.requiredAmount?.toString(),
+      userBalance: args.userBalance?.toString(),
+      errorMessage: errorDetails.message,
+      errorCode: errorDetails.code ? stringify(errorDetails.code) : undefined,
+    },
+  });
+}

package/src/gas/fee-data.ts

@@ -46,6 +46,7 @@ const FORCE_GAS_PRICE_CHAIN_IDS = [
   5464, // Saga Mainnet
   2020, // Ronin Mainnet
   2021, // Ronin Testnet (Saigon)
+  98866, // Plume mainnet
 ];
 
 /**

package/src/react/core/hooks/transaction/useSendTransaction.ts

@@ -1,5 +1,7 @@
 import { type UseMutationResult, useMutation } from "@tanstack/react-query";
+import { isInsufficientFundsError } from "../../../../analytics/track/helpers.js";
 import { trackPayEvent } from "../../../../analytics/track/pay.js";
+import { trackInsufficientFundsError } from "../../../../analytics/track/transaction.js";
 import * as Bridge from "../../../../bridge/index.js";
 import type { Chain } from "../../../../chains/types.js";
 import type { BuyWithCryptoStatus } from "../../../../pay/buyWithCrypto/getStatus.js";
@@ -174,6 +176,18 @@ export function useSendTransactionCore(args: {
 
             resolve(res);
           } catch (e) {
+            // Track insufficient funds errors specifically
+            if (isInsufficientFundsError(e)) {
+              trackInsufficientFundsError({
+                client: tx.client,
+                error: e,
+                walletAddress: account.address,
+                chainId: tx.chain.id,
+                contractAddress: await resolvePromisedValue(tx.to ?? undefined),
+                transactionValue: await resolvePromisedValue(tx.value),
+              });
+            }
+
             reject(e);
           }
         };

package/src/transaction/actions/estimate-gas.ts

@@ -94,6 +94,7 @@ export async function estimateGas(
         throw await extractError({
           error,
           contract: options.transaction.__contract,
+          fromAddress,
         });
       }
     }
@@ -150,6 +151,7 @@ export async function estimateGas(
       throw await extractError({
         error,
         contract: options.transaction.__contract,
+        fromAddress,
       });
     }
   })();

package/src/transaction/actions/simulate.ts

@@ -89,6 +89,7 @@ export async function simulateTransaction<
     throw await extractError({
       error,
       contract: options.transaction.__contract,
+      fromAddress: from,
     });
   }
 }

package/src/transaction/extract-error.ts

@@ -1,5 +1,7 @@
 import type { Abi } from "abitype";
 import { type Hex, decodeErrorResult, stringify } from "viem";
+import { isInsufficientFundsError } from "../analytics/track/helpers.js";
+import { trackInsufficientFundsError } from "../analytics/track/transaction.js";
 import { resolveContractAbi } from "../contract/actions/resolve-abi.js";
 import type { ThirdwebContract } from "../contract/contract.js";
 import { isHex } from "../utils/encoding/hex.js";
@@ -11,8 +13,21 @@ import { IS_DEV } from "../utils/process.js";
 export async function extractError<abi extends Abi>(args: {
   error: unknown;
   contract?: ThirdwebContract<abi>;
+  fromAddress?: string;
 }) {
-  const { error, contract } = args;
+  const { error, contract, fromAddress } = args;
+
+  // Track insufficient funds errors during transaction preparation
+  if (isInsufficientFundsError(error) && contract) {
+    trackInsufficientFundsError({
+      client: contract.client,
+      error,
+      walletAddress: fromAddress,
+      chainId: contract.chain?.id,
+      contractAddress: contract.address,
+    });
+  }
+
   const result = await extractErrorResult({ error, contract });
   if (result) {
     return new TransactionError(result, contract);

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.102.4-nightly-283dc289fca1ad16a9296e610d293b73a7123709-20250602000433";
+export const version = "5.102.4-nightly-3d1c321bd6f5783bdee43185deef88f91b325a23-20250604000438";

package/src/wallets/injected/index.ts

@@ -5,7 +5,9 @@ import {
   serializeTypedData,
   validateTypedData,
 } from "viem";
+import { isInsufficientFundsError } from "../../analytics/track/helpers.js";
 import { trackTransaction } from "../../analytics/track/transaction.js";
+import { trackInsufficientFundsError } from "../../analytics/track/transaction.js";
 import type { Chain } from "../../chains/types.js";
 import { getCachedChain, getChainMetadata } from "../../chains/utils.js";
 import type { ThirdwebClient } from "../../client/client.js";
@@ -200,25 +202,41 @@ function createAccount({
         },
       ];
 
-      const transactionHash = (await provider.request({
-        method: "eth_sendTransaction",
-        // @ts-expect-error - overriding types here
-        params,
-      })) as Hex;
-
-      trackTransaction({
-        client,
-        chainId: tx.chainId,
-        walletAddress: getAddress(address),
-        walletType: id,
-        transactionHash,
-        contractAddress: tx.to ?? undefined,
-        gasPrice: tx.gasPrice,
-      });
+      try {
+        const transactionHash = (await provider.request({
+          method: "eth_sendTransaction",
+          // @ts-expect-error - overriding types here
+          params,
+        })) as Hex;
+
+        trackTransaction({
+          client,
+          chainId: tx.chainId,
+          walletAddress: getAddress(address),
+          walletType: id,
+          transactionHash,
+          contractAddress: tx.to ?? undefined,
+          gasPrice: tx.gasPrice,
+        });
+
+        return {
+          transactionHash,
+        };
+      } catch (error) {
+        // Track insufficient funds errors
+        if (isInsufficientFundsError(error)) {
+          trackInsufficientFundsError({
+            client,
+            error,
+            walletAddress: getAddress(address),
+            chainId: tx.chainId,
+            contractAddress: tx.to || undefined,
+            transactionValue: tx.value,
+          });
+        }
 
-      return {
-        transactionHash,
-      };
+        throw error;
+      }
     },
     async signMessage({ message }) {
       if (!account.address) {

package/src/wallets/smart/index.ts

@@ -1,5 +1,7 @@
 import type * as ox__TypedData from "ox/TypedData";
+import { isInsufficientFundsError } from "../../analytics/track/helpers.js";
 import { trackTransaction } from "../../analytics/track/transaction.js";
+import { trackInsufficientFundsError } from "../../analytics/track/transaction.js";
 import type { Chain } from "../../chains/types.js";
 import { getCachedChain } from "../../chains/utils.js";
 import type { ThirdwebClient } from "../../client/client.js";
@@ -559,6 +561,20 @@ async function _sendUserOp(args: {
       chain: options.chain,
       transactionHash: receipt.transactionHash,
     };
+  } catch (error) {
+    // Track insufficient funds errors
+    if (isInsufficientFundsError(error)) {
+      trackInsufficientFundsError({
+        client: options.client,
+        error,
+        walletAddress: options.accountContract.address,
+        chainId: options.chain.id,
+        contractAddress: await resolvePromisedValue(executeTx.to ?? undefined),
+        transactionValue: await resolvePromisedValue(executeTx.value),
+      });
+    }
+
+    throw error;
   } finally {
     // reset the isDeploying flag after every transaction or error
     clearAccountDeploying(options.accountContract);