thirdweb 5.121.1 → 5.121.3

package/src/extensions/modules/ClaimableERC1155/claimableERC1155.test.ts

@@ -20,234 +20,236 @@ import { getInstalledModules } from "../__generated__/IModularCore/read/getInsta
 import * as BatchMetadataERC1155 from "../BatchMetadataERC1155/index.js";
 import * as ClaimableERC1155 from "./index.js";
 
-describe.runIf(process.env.TW_SECRET_KEY)("ModularClaimableERC1155", () => {
-  let contract: ThirdwebContract;
-  beforeAll(async () => {
-    const address = await deployModularContract({
-      account: TEST_ACCOUNT_A,
-      chain: ANVIL_CHAIN,
-      client: TEST_CLIENT,
-      core: "ERC1155",
-      modules: [
-        ClaimableERC1155.module({
-          primarySaleRecipient: TEST_ACCOUNT_A.address,
+describe
+  .runIf(process.env.TW_SECRET_KEY)
+  .skip("ModularClaimableERC1155", () => {
+    let contract: ThirdwebContract;
+    beforeAll(async () => {
+      const address = await deployModularContract({
+        account: TEST_ACCOUNT_A,
+        chain: ANVIL_CHAIN,
+        client: TEST_CLIENT,
+        core: "ERC1155",
+        modules: [
+          ClaimableERC1155.module({
+            primarySaleRecipient: TEST_ACCOUNT_A.address,
+          }),
+          BatchMetadataERC1155.module(),
+        ],
+        params: {
+          contractURI: TEST_CONTRACT_URI,
+          name: "TestDropERC1155",
+        },
+      });
+      contract = getContract({
+        address,
+        chain: ANVIL_CHAIN,
+        client: TEST_CLIENT,
+      });
+    }, 120000);
+
+    it("should have erc1155 module", async () => {
+      const modules = await getInstalledModules({ contract });
+      expect(modules.length).toBe(2);
+    });
+
+    it("should upload metadata", async () => {
+      const transaction = BatchMetadataERC1155.uploadMetadata({
+        contract,
+        metadatas: Array.from(
+          { length: 10 },
+          (_, index) =>
+            `ipfs://QmP4JFzBhTGvb27GnJ9eL9vZGYpNBGjHnPudWndruiNERm/${index}`,
+        ),
+      });
+
+      await sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_A,
+        transaction,
+      });
+    });
+
+    it("should not claim without claim conditions", async () => {
+      // should throw
+      await expect(
+        sendAndConfirmTransaction({
+          account: TEST_ACCOUNT_A,
+          transaction: ClaimableERC1155.mint({
+            contract,
+            quantity: 1,
+            to: TEST_ACCOUNT_A.address,
+            tokenId: 123123123213n,
+          }),
         }),
-        BatchMetadataERC1155.module(),
-      ],
-      params: {
-        contractURI: TEST_CONTRACT_URI,
-        name: "TestDropERC1155",
-      },
-    });
-    contract = getContract({
-      address,
-      chain: ANVIL_CHAIN,
-      client: TEST_CLIENT,
-    });
-  }, 120000);
-
-  it("should have erc1155 module", async () => {
-    const modules = await getInstalledModules({ contract });
-    expect(modules.length).toBe(2);
-  });
-
-  it("should upload metadata", async () => {
-    const transaction = BatchMetadataERC1155.uploadMetadata({
-      contract,
-      metadatas: Array.from(
-        { length: 10 },
-        (_, index) =>
-          `ipfs://QmP4JFzBhTGvb27GnJ9eL9vZGYpNBGjHnPudWndruiNERm/${index}`,
-      ),
-    });
-
-    await sendAndConfirmTransaction({
-      account: TEST_ACCOUNT_A,
-      transaction,
+      ).rejects.toThrowError(/ClaimableOutOfTimeWindow/);
     });
-  });
 
-  it("should not claim without claim conditions", async () => {
-    // should throw
-    await expect(
-      sendAndConfirmTransaction({
+    it("should claim tokens with claim conditions", async () => {
+      await sendAndConfirmTransaction({
         account: TEST_ACCOUNT_A,
-        transaction: ClaimableERC1155.mint({
+        transaction: ClaimableERC1155.setClaimCondition({
           contract,
-          quantity: 1,
-          to: TEST_ACCOUNT_A.address,
-          tokenId: 123123123213n,
+          maxClaimableSupply: "1",
+          pricePerToken: "0.1",
+          tokenId: 0n,
         }),
-      }),
-    ).rejects.toThrowError(/ClaimableOutOfTimeWindow/);
-  });
+      });
+
+      // should throw if claiming more than supply
+      await expect(
+        sendAndConfirmTransaction({
+          account: TEST_ACCOUNT_A,
+          transaction: ClaimableERC1155.mint({
+            contract,
+            quantity: 1000,
+            to: TEST_ACCOUNT_A.address,
+            tokenId: 0n,
+          }),
+        }),
+      ).rejects.toThrowError(/ClaimableOutOfSupply/);
 
-  it("should claim tokens with claim conditions", async () => {
-    await sendAndConfirmTransaction({
-      account: TEST_ACCOUNT_A,
-      transaction: ClaimableERC1155.setClaimCondition({
+      let balance = await balanceOf({
         contract,
-        maxClaimableSupply: "1",
-        pricePerToken: "0.1",
+        owner: TEST_ACCOUNT_A.address,
         tokenId: 0n,
-      }),
-    });
+      });
 
-    // should throw if claiming more than supply
-    await expect(
-      sendAndConfirmTransaction({
+      expect(balance).toBe(0n);
+
+      await sendAndConfirmTransaction({
         account: TEST_ACCOUNT_A,
         transaction: ClaimableERC1155.mint({
           contract,
-          quantity: 1000,
+          quantity: 1,
           to: TEST_ACCOUNT_A.address,
           tokenId: 0n,
         }),
-      }),
-    ).rejects.toThrowError(/ClaimableOutOfSupply/);
+      });
 
-    let balance = await balanceOf({
-      contract,
-      owner: TEST_ACCOUNT_A.address,
-      tokenId: 0n,
-    });
-
-    expect(balance).toBe(0n);
-
-    await sendAndConfirmTransaction({
-      account: TEST_ACCOUNT_A,
-      transaction: ClaimableERC1155.mint({
+      balance = await balanceOf({
         contract,
-        quantity: 1,
-        to: TEST_ACCOUNT_A.address,
+        owner: TEST_ACCOUNT_A.address,
         tokenId: 0n,
-      }),
-    });
+      });
+      expect(balance).toBe(1n);
 
-    balance = await balanceOf({
-      contract,
-      owner: TEST_ACCOUNT_A.address,
-      tokenId: 0n,
-    });
-    expect(balance).toBe(1n);
-
-    const all = await getNFTs({
-      contract,
-    });
-    expect(all.length).toBe(10);
-
-    const owned = await getOwnedNFTs({
-      address: TEST_ACCOUNT_A.address,
-      contract,
-    });
-    expect(owned.length).toBe(1);
-    expect(owned?.[0]?.metadata.name).toBe("Test 0");
-    expect(owned?.[0]?.quantityOwned).toBe(1n);
-  });
+      const all = await getNFTs({
+        contract,
+      });
+      expect(all.length).toBe(10);
 
-  it("should claim tokens with allowlist", async () => {
-    await sendAndConfirmTransaction({
-      account: TEST_ACCOUNT_A,
-      transaction: ClaimableERC1155.setClaimCondition({
-        allowList: [TEST_ACCOUNT_A.address, TEST_ACCOUNT_B.address],
+      const owned = await getOwnedNFTs({
+        address: TEST_ACCOUNT_A.address,
         contract,
-        maxClaimableSupply: "2",
-        pricePerToken: "0.1",
-        tokenId: 0n,
-      }),
+      });
+      expect(owned.length).toBe(1);
+      expect(owned?.[0]?.metadata.name).toBe("Test 0");
+      expect(owned?.[0]?.quantityOwned).toBe(1n);
     });
 
-    // should throw if not in allowlist
-    await expect(
-      sendAndConfirmTransaction({
-        account: TEST_ACCOUNT_C,
-        transaction: ClaimableERC1155.mint({
+    it("should claim tokens with allowlist", async () => {
+      await sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_A,
+        transaction: ClaimableERC1155.setClaimCondition({
+          allowList: [TEST_ACCOUNT_A.address, TEST_ACCOUNT_B.address],
           contract,
-          quantity: 1,
-          to: TEST_ACCOUNT_C.address,
+          maxClaimableSupply: "2",
+          pricePerToken: "0.1",
           tokenId: 0n,
         }),
-      }),
-    ).rejects.toThrowError(/ClaimableNotInAllowlist/);
+      });
+
+      // should throw if not in allowlist
+      await expect(
+        sendAndConfirmTransaction({
+          account: TEST_ACCOUNT_C,
+          transaction: ClaimableERC1155.mint({
+            contract,
+            quantity: 1,
+            to: TEST_ACCOUNT_C.address,
+            tokenId: 0n,
+          }),
+        }),
+      ).rejects.toThrowError(/ClaimableNotInAllowlist/);
+
+      // should throw if in allowlist but over supply
+      await expect(
+        sendAndConfirmTransaction({
+          account: TEST_ACCOUNT_C,
+          transaction: ClaimableERC1155.mint({
+            contract,
+            quantity: 3,
+            to: TEST_ACCOUNT_C.address,
+            tokenId: 0n,
+          }),
+        }),
+      ).rejects.toThrowError(/ClaimableOutOfSupply/);
 
-    // should throw if in allowlist but over supply
-    await expect(
-      sendAndConfirmTransaction({
+      // can claim to address in allowlist (regardless of sender)
+      await sendAndConfirmTransaction({
         account: TEST_ACCOUNT_C,
         transaction: ClaimableERC1155.mint({
           contract,
-          quantity: 3,
-          to: TEST_ACCOUNT_C.address,
+          quantity: 2,
+          to: TEST_ACCOUNT_B.address,
           tokenId: 0n,
         }),
-      }),
-    ).rejects.toThrowError(/ClaimableOutOfSupply/);
+      });
 
-    // can claim to address in allowlist (regardless of sender)
-    await sendAndConfirmTransaction({
-      account: TEST_ACCOUNT_C,
-      transaction: ClaimableERC1155.mint({
+      const balance = await balanceOf({
         contract,
-        quantity: 2,
-        to: TEST_ACCOUNT_B.address,
+        owner: TEST_ACCOUNT_B.address,
         tokenId: 0n,
-      }),
+      });
+      expect(balance).toBe(2n);
     });
 
-    const balance = await balanceOf({
-      contract,
-      owner: TEST_ACCOUNT_B.address,
-      tokenId: 0n,
-    });
-    expect(balance).toBe(2n);
-  });
+    it("should claim tokens with max per wallet", async () => {
+      await sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_A,
+        transaction: ClaimableERC1155.setClaimCondition({
+          contract,
+          maxClaimablePerWallet: 1,
+          maxClaimableSupply: 10,
+          tokenId: 0n,
+        }),
+      });
 
-  it("should claim tokens with max per wallet", async () => {
-    await sendAndConfirmTransaction({
-      account: TEST_ACCOUNT_A,
-      transaction: ClaimableERC1155.setClaimCondition({
+      let balance = await balanceOf({
         contract,
-        maxClaimablePerWallet: 1,
-        maxClaimableSupply: 10,
+        owner: TEST_ACCOUNT_C.address,
         tokenId: 0n,
-      }),
-    });
-
-    let balance = await balanceOf({
-      contract,
-      owner: TEST_ACCOUNT_C.address,
-      tokenId: 0n,
-    });
-    expect(balance).toBe(0n);
+      });
+      expect(balance).toBe(0n);
+
+      // should throw if max per wallet is reached
+      await expect(
+        sendAndConfirmTransaction({
+          account: TEST_ACCOUNT_C,
+          transaction: ClaimableERC1155.mint({
+            contract,
+            quantity: 4,
+            to: TEST_ACCOUNT_C.address,
+            tokenId: 0n,
+          }),
+        }),
+      ).rejects.toThrowError(/ClaimableMaxMintPerWalletExceeded/);
 
-    // should throw if max per wallet is reached
-    await expect(
-      sendAndConfirmTransaction({
+      await sendAndConfirmTransaction({
         account: TEST_ACCOUNT_C,
         transaction: ClaimableERC1155.mint({
           contract,
-          quantity: 4,
+          quantity: 1,
           to: TEST_ACCOUNT_C.address,
           tokenId: 0n,
         }),
-      }),
-    ).rejects.toThrowError(/ClaimableMaxMintPerWalletExceeded/);
+      });
 
-    await sendAndConfirmTransaction({
-      account: TEST_ACCOUNT_C,
-      transaction: ClaimableERC1155.mint({
+      balance = await balanceOf({
         contract,
-        quantity: 1,
-        to: TEST_ACCOUNT_C.address,
+        owner: TEST_ACCOUNT_C.address,
         tokenId: 0n,
-      }),
-    });
-
-    balance = await balanceOf({
-      contract,
-      owner: TEST_ACCOUNT_C.address,
-      tokenId: 0n,
+      });
+      expect(balance).toBe(1n);
     });
-    expect(balance).toBe(1n);
   });
-});

package/src/extensions/modules/ClaimableERC20/claimableERC20.test.ts

@@ -17,7 +17,7 @@ import { deployModularContract } from "../../prebuilts/deploy-modular.js";
 import { getInstalledModules } from "../__generated__/IModularCore/read/getInstalledModules.js";
 import * as ClaimableERC20 from "./index.js";
 
-describe.runIf(process.env.TW_SECRET_KEY)("ModularDropERC20", () => {
+describe.runIf(process.env.TW_SECRET_KEY).skip("ModularDropERC20", () => {
   let contract: ThirdwebContract;
   beforeAll(async () => {
     const address = await deployModularContract({

package/src/extensions/modules/ClaimableERC721/claimableERC721.test.ts

@@ -18,7 +18,7 @@ import { getInstalledModules } from "../__generated__/IModularCore/read/getInsta
 import * as BatchMetadataERC721 from "../BatchMetadataERC721/index.js";
 import * as ClaimableERC721 from "./index.js";
 
-describe.runIf(process.env.TW_SECRET_KEY)("ModularClaimableERC721", () => {
+describe.runIf(process.env.TW_SECRET_KEY).skip("ModularClaimableERC721", () => {
   let contract: ThirdwebContract;
   beforeAll(async () => {
     const address = await deployModularContract({

package/src/extensions/prebuilts/process-ref-deployments.test.ts

@@ -8,7 +8,7 @@ import { readContract } from "../../transaction/read-contract.js";
 import { getInstalledModules } from "../modules/__generated__/IModularCore/read/getInstalledModules.js";
 import { deployPublishedContract } from "./deploy-published.js";
 
-describe.runIf(process.env.TW_SECRET_KEY)(
+describe.runIf(process.env.TW_SECRET_KEY).skip(
   "deployref",
   {
     timeout: 120000,

package/src/react/core/hooks/x402/useFetchWithPaymentCore.ts

@@ -4,7 +4,10 @@ import { useMutation } from "@tanstack/react-query";
 import type { ThirdwebClient } from "../../../../client/client.js";
 import type { AsyncStorage } from "../../../../utils/storage/AsyncStorage.js";
 import type { Wallet } from "../../../../wallets/interfaces/wallet.js";
-import { wrapFetchWithPayment } from "../../../../x402/fetchWithPayment.js";
+import {
+  getRequestUrl,
+  wrapFetchWithPayment,
+} from "../../../../x402/fetchWithPayment.js";
 import type { RequestedPaymentRequirements } from "../../../../x402/schemas.js";
 import type { PaymentRequiredResult } from "../../../../x402/types.js";
 import { useActiveWallet } from "../wallets/useActiveWallet.js";
@@ -24,6 +27,7 @@ export type UseFetchWithPaymentOptions = {
 
 type ShowErrorModalCallback = (data: {
   errorData: PaymentRequiredResult["responseBody"];
+  requestUrl?: string;
   onRetry: () => void;
   onCancel: () => void;
 }) => void;
@@ -107,6 +111,7 @@ export function useFetchWithPaymentCore(
               return new Promise<unknown>((resolve, reject) => {
                 showErrorModal({
                   errorData: errorBody,
+                  requestUrl: getRequestUrl(input),
                   onRetry: async () => {
                     // Retry the entire fetch+error handling logic recursively
                     // Pass currentWallet to avoid re-showing connect modal with stale wallet state

package/src/react/native/hooks/x402/useFetchWithPayment.ts

@@ -27,7 +27,7 @@ export type { UseFetchWithPaymentOptions };
  *
  * @param client - The thirdweb client used to access RPC infrastructure
  * @param options - Optional configuration for payment handling
- * @param options.maxValue - The maximum allowed payment amount in base units
+ * @param options.maxValue - The maximum allowed payment amount in base units. `0n` only allows zero-amount payments
  * @param options.paymentRequirementsSelector - Custom function to select payment requirements from available options
  * @param options.parseAs - How to parse the response: "json" (default), "text", or "raw"
  * @param options.storage - Storage for caching permit signatures (for "upto" scheme). Provide your own AsyncStorage implementation for React Native.

package/src/react/web/hooks/x402/useFetchWithPayment.tsx

@@ -78,7 +78,7 @@ type UseFetchWithPaymentConfig = UseFetchWithPaymentOptions & {
  *
  * @param client - The thirdweb client used to access RPC infrastructure
  * @param options - Optional configuration for payment handling
- * @param options.maxValue - The maximum allowed payment amount in base units
+ * @param options.maxValue - The maximum allowed payment amount in base units. `0n` only allows zero-amount payments
  * @param options.paymentRequirementsSelector - Custom function to select payment requirements from available options
  * @param options.parseAs - How to parse the response: "json" (default), "text", or "raw"
  * @param options.uiEnabled - Whether to show the UI for connection, funding or payment retries (defaults to true). Set to false to handle errors yourself
@@ -196,6 +196,7 @@ export function useFetchWithPayment(
   const showErrorModal = showModal
     ? (data: {
         errorData: Parameters<typeof PaymentErrorModal>[0]["errorData"];
+        requestUrl?: string;
         onRetry: () => void;
         onCancel: () => void;
       }) => {
@@ -203,6 +204,7 @@ export function useFetchWithPayment(
           <PaymentErrorModal
             client={client}
             errorData={data.errorData}
+            requestUrl={data.requestUrl}
             onCancel={() => {
               setRootEl(null);
               data.onCancel();

package/src/react/web/ui/Bridge/common/token-query.test.tsx

@@ -0,0 +1,117 @@
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import type { TokenWithPrices } from "../../../../../bridge/index.js";
+import { getToken } from "../../../../../pay/convert/get-token.js";
+import { useTokenQuery } from "./token-query.js";
+
+vi.mock("../../../../../pay/convert/get-token.js", () => ({
+  getToken: vi.fn(),
+}));
+
+const TOKEN_ADDRESS = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359";
+const CHAIN_ID = 137;
+
+const MOCK_TOKEN = {
+  address: TOKEN_ADDRESS,
+  chainId: CHAIN_ID,
+  decimals: 6,
+  name: "USD Coin",
+  prices: { USD: 1 },
+  symbol: "USDC",
+} as TokenWithPrices;
+
+const createWrapper = () => {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+      },
+    },
+  });
+  return ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  );
+};
+
+describe("useTokenQuery", () => {
+  beforeEach(() => {
+    vi.mocked(getToken).mockReset();
+  });
+
+  it("returns success when getToken resolves", async () => {
+    vi.mocked(getToken).mockResolvedValue(MOCK_TOKEN);
+
+    const { result } = renderHook(
+      () =>
+        useTokenQuery({
+          chainId: CHAIN_ID,
+          client: TEST_CLIENT,
+          tokenAddress: TOKEN_ADDRESS,
+        }),
+      { wrapper: createWrapper() },
+    );
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual({
+      token: MOCK_TOKEN,
+      type: "success",
+    });
+  });
+
+  it("returns unsupported_token when getToken throws a not-supported Error", async () => {
+    vi.mocked(getToken).mockRejectedValue(new Error("Token not supported"));
+
+    const { result } = renderHook(
+      () =>
+        useTokenQuery({
+          chainId: CHAIN_ID,
+          client: TEST_CLIENT,
+          tokenAddress: TOKEN_ADDRESS,
+        }),
+      { wrapper: createWrapper() },
+    );
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual({ type: "unsupported_token" });
+    expect(result.current.isError).toBe(false);
+  });
+
+  it("surfaces 401 failures as query errors instead of unsupported_token", async () => {
+    vi.mocked(getToken).mockRejectedValue(new Error("401 Unauthorized"));
+
+    const { result } = renderHook(
+      () =>
+        useTokenQuery({
+          chainId: CHAIN_ID,
+          client: TEST_CLIENT,
+          tokenAddress: TOKEN_ADDRESS,
+        }),
+      { wrapper: createWrapper() },
+    );
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.data).toBeUndefined();
+    expect(result.current.error).toBeInstanceOf(Error);
+    expect((result.current.error as Error).message).toBe("401 Unauthorized");
+  });
+
+  it("surfaces non-Error rejections as query errors instead of unsupported_token", async () => {
+    vi.mocked(getToken).mockRejectedValue("timeout");
+
+    const { result } = renderHook(
+      () =>
+        useTokenQuery({
+          chainId: CHAIN_ID,
+          client: TEST_CLIENT,
+          tokenAddress: TOKEN_ADDRESS,
+        }),
+      { wrapper: createWrapper() },
+    );
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.data).toBeUndefined();
+  });
+});

package/src/react/web/ui/Bridge/common/token-query.ts

@@ -27,7 +27,10 @@ export function useTokenQuery(params: {
         tokenAddress,
         params.chainId,
       ).catch((err) => {
-        err.message.includes("not supported") ? undefined : Promise.reject(err);
+        if (err instanceof Error && err.message.includes("not supported")) {
+          return undefined;
+        }
+        throw err;
       });
 
       if (!token) {

package/src/react/web/ui/x402/PaymentErrorModal.tsx

@@ -5,6 +5,7 @@ import type { ThirdwebClient } from "../../../../client/client.js";
 import {
   extractEvmChainId,
   networkToCaip2ChainId,
+  parsePaymentRequirementsForDisplay,
   type RequestedPaymentRequirements,
 } from "../../../../x402/schemas.js";
 import type { PaymentRequiredResult } from "../../../../x402/types.js";
@@ -25,6 +26,7 @@ import { Text } from "../components/text.js";
 type PaymentErrorModalProps = {
   client: ThirdwebClient;
   errorData: PaymentRequiredResult["responseBody"];
+  requestUrl?: string;
   onRetry: () => void;
   onCancel: () => void;
   theme: Theme | "light" | "dark";
@@ -54,6 +56,7 @@ export function PaymentErrorModal(props: PaymentErrorModalProps) {
   const {
     client,
     errorData,
+    requestUrl,
     onRetry,
     onCancel,
     theme,
@@ -66,13 +69,15 @@ export function PaymentErrorModal(props: PaymentErrorModalProps) {
 
   // Extract chain and token info from errorData for BuyWidget
   const getBuyWidgetConfig = () => {
-    if (!errorData.accepts || errorData.accepts.length === 0) {
+    // Get payment requirements from errorData
+    const parsedPaymentRequirements = parsePaymentRequirementsForDisplay(
+      errorData,
+      requestUrl,
+    );
+    if (parsedPaymentRequirements.length === 0) {
       return null;
     }
 
-    // Get payment requirements from errorData
-    const parsedPaymentRequirements = errorData.accepts;
-
     // Get the current chain from wallet
     const currentChain = wallet?.getChain();
     const currentChainId = currentChain?.id;