thirdweb 5.89.0 → 5.90.0

package/src/contract/actions/resolve-abi.ts

@@ -1,10 +1,9 @@
 import { type Abi, formatAbi, parseAbi } from "abitype";
 import { download } from "../../storage/download.js";
 import { getClientFetch } from "../../utils/fetch.js";
+import { withCache } from "../../utils/promise/withCache.js";
 import { type ThirdwebContract, getContract } from "../contract.js";
 
-const ABI_RESOLUTION_CACHE = new WeakMap<ThirdwebContract<Abi>, Promise<Abi>>();
-
 /**
  * Resolves the ABI (Application Binary Interface) for a given contract.
  * If the ABI is already cached, it returns the cached value.
@@ -32,31 +31,34 @@ export function resolveContractAbi<abi extends Abi>(
   contract: ThirdwebContract<abi>,
   contractApiBaseUrl = "https://contract.thirdweb.com/abi",
 ): Promise<abi> {
-  if (ABI_RESOLUTION_CACHE.has(contract)) {
-    return ABI_RESOLUTION_CACHE.get(contract) as Promise<abi>;
-  }
-
-  const prom = (async () => {
-    // if the contract already HAS a user defined we always use that!
-    if (contract.abi) {
-      return contract.abi as abi;
-    }
+  return withCache(
+    async () => {
+      // if the contract already HAS a user defined we always use that!
+      if (contract.abi) {
+        return contract.abi as abi;
+      }
 
-    // for local chains, we need to resolve the composite abi from bytecode
-    if (contract.chain.id === 31337 || contract.chain.id === 1337) {
-      return await resolveCompositeAbi(contract as ThirdwebContract);
-    }
+      // for local chains, we need to resolve the composite abi from bytecode
+      if (contract.chain.id === 31337 || contract.chain.id === 1337) {
+        return (await resolveCompositeAbi(contract as ThirdwebContract)) as abi;
+      }
 
-    // try to get it from the api
-    try {
-      return await resolveAbiFromContractApi(contract, contractApiBaseUrl);
-    } catch {
-      // if that fails, try to resolve it from the bytecode
-      return await resolveCompositeAbi(contract as ThirdwebContract);
-    }
-  })();
-  ABI_RESOLUTION_CACHE.set(contract, prom);
-  return prom as Promise<abi>;
+      // try to get it from the api
+      try {
+        return (await resolveAbiFromContractApi(
+          contract,
+          contractApiBaseUrl,
+        )) as abi;
+      } catch {
+        // if that fails, try to resolve it from the bytecode
+        return (await resolveCompositeAbi(contract as ThirdwebContract)) as abi;
+      }
+    },
+    {
+      cacheKey: `${contract.chain.id}-${contract.address}`,
+      cacheTime: 1000 * 60 * 60 * 1, // 1 hour
+    },
+  );
 }
 
 /**

package/src/exports/extensions/erc721.ts

@@ -16,6 +16,7 @@ export {
   nextTokenIdToMint,
   isNextTokenIdToMintSupported,
 } from "../../extensions/erc721/__generated__/IERC721Enumerable/read/nextTokenIdToMint.js";
+export { isTokenByIndexSupported } from "../../extensions/erc721/__generated__/IERC721Enumerable/read/tokenByIndex.js";
 export {
   ownerOf,
   type OwnerOfParams,

package/src/exports/wallets/smart.ts

@@ -13,6 +13,7 @@ export {
   bundleUserOp,
   getUserOpGasFees,
   estimateUserOpGas,
+  estimateUserOpGasCost,
 } from "../../wallets/smart/lib/bundler.js";
 
 export {

package/src/extensions/erc1155/customDrop1155.test.ts

@@ -69,20 +69,9 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       });
 
       await expect(nextTokenIdToMint({ contract })).resolves.toBe(6n);
-      await expect(
-        getNFT({ contract, tokenId: 0n }),
-      ).resolves.toMatchInlineSnapshot(`
-          {
-            "id": 0n,
-            "metadata": {
-              "name": "Test NFT",
-            },
-            "owner": null,
-            "supply": 0n,
-            "tokenURI": "ipfs://QmTo68Dm1ntSp2BHLmE9gesS6ELuXosRz5mAgFCK6tfsRk/0",
-            "type": "ERC1155",
-          }
-        `);
+      expect((await getNFT({ contract, tokenId: 0n })).metadata.name).toBe(
+        "Test NFT",
+      );
     });
 
     it("should allow to claim tokens", async () => {

package/src/extensions/erc1155/drop1155.test.ts

@@ -89,20 +89,9 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       });
 
       await expect(nextTokenIdToMint({ contract })).resolves.toBe(6n);
-      await expect(
-        getNFT({ contract, tokenId: 0n }),
-      ).resolves.toMatchInlineSnapshot(`
-        {
-          "id": 0n,
-          "metadata": {
-            "name": "Test NFT",
-          },
-          "owner": null,
-          "supply": 0n,
-          "tokenURI": "ipfs://QmTo68Dm1ntSp2BHLmE9gesS6ELuXosRz5mAgFCK6tfsRk/0",
-          "type": "ERC1155",
-        }
-      `);
+      expect((await getNFT({ contract, tokenId: 0n })).metadata.name).toBe(
+        "Test NFT",
+      );
     });
 
     it("should update metadata", async () => {

package/src/extensions/erc1155/token1155.test.ts

@@ -81,20 +81,9 @@ describe.runIf(process.env.TW_SECRET_KEY)("TokenERC1155", () => {
     // now 1 token minted
     await expect(nextTokenIdToMint({ contract })).resolves.toBe(1n);
     // tokenId 0 is minted
-    await expect(
-      getNFT({ contract, tokenId: 0n }),
-    ).resolves.toMatchInlineSnapshot(`
-        {
-          "id": 0n,
-          "metadata": {
-            "name": "Test NFT",
-          },
-          "owner": null,
-          "supply": 10n,
-          "tokenURI": "ipfs://QmUut8sypH8NaPUeksnirut7MgggMeQa9RvJ37sV513sw3/0",
-          "type": "ERC1155",
-        }
-      `);
+    expect((await getNFT({ contract, tokenId: 0n })).metadata.name).toBe(
+      "Test NFT",
+    );
     // account should have a balance of 10
     await expect(
       balanceOf({ contract, owner: TEST_ACCOUNT_A.address, tokenId: 0n }),
@@ -119,20 +108,8 @@ describe.runIf(process.env.TW_SECRET_KEY)("TokenERC1155", () => {
     await expect(nextTokenIdToMint({ contract })).resolves.toBe(1n);
     // tokenId 0 is minted
     // supply should be 15
-    await expect(
-      getNFT({ contract, tokenId: 0n }),
-    ).resolves.toMatchInlineSnapshot(`
-        {
-          "id": 0n,
-          "metadata": {
-            "name": "Test NFT",
-          },
-          "owner": null,
-          "supply": 15n,
-          "tokenURI": "ipfs://QmUut8sypH8NaPUeksnirut7MgggMeQa9RvJ37sV513sw3/0",
-          "type": "ERC1155",
-        }
-      `);
+    // @ts-expect-error - supply is there
+    expect((await getNFT({ contract, tokenId: 0n })).supply).toBe(15n);
     // account should have a balance of 15
     await expect(
       balanceOf({ contract, owner: TEST_ACCOUNT_A.address, tokenId: 0n }),
@@ -155,30 +132,13 @@ describe.runIf(process.env.TW_SECRET_KEY)("TokenERC1155", () => {
 
     // now 2 tokens minted
     await expect(nextTokenIdToMint({ contract })).resolves.toBe(2n);
-    await expect(getNFTs({ contract })).resolves.toMatchInlineSnapshot(`
-      [
-        {
-          "id": 0n,
-          "metadata": {
-            "name": "Test NFT",
-          },
-          "owner": null,
-          "supply": 15n,
-          "tokenURI": "ipfs://QmUut8sypH8NaPUeksnirut7MgggMeQa9RvJ37sV513sw3/0",
-          "type": "ERC1155",
-        },
-        {
-          "id": 1n,
-          "metadata": {
-            "name": "Test NFT 2",
-          },
-          "owner": null,
-          "supply": 5n,
-          "tokenURI": "ipfs://QmV6gsfzdiMRtpnh8ay3CgutStVbes7qoF4DKpYE64h8hT/0",
-          "type": "ERC1155",
-        },
-      ]
-    `);
+    await expect(getNFTs({ contract })).resolves.length(2);
+    expect((await getNFT({ contract, tokenId: 0n })).metadata.name).toBe(
+      "Test NFT",
+    );
+    expect((await getNFT({ contract, tokenId: 1n })).metadata.name).toBe(
+      "Test NFT 2",
+    );
   });
 
   it("isGetNFTsSupported should work with our Edition contracts", async () => {
@@ -241,63 +201,10 @@ describe.runIf(process.env.TW_SECRET_KEY)("TokenERC1155", () => {
     });
 
     const nfts = await getNFTs({ contract });
-    expect(nfts).toStrictEqual([
-      {
-        // Updated tokenURI from the test above
-        metadata: { name: "Test1 Updated" },
-        owner: null,
-        id: 0n,
-        tokenURI: "ipfs://QmTSyt6YgoFtH8yhWgevC22BxjyrkCKuzdk86nqQJCwrV9/0",
-        type: "ERC1155",
-        supply: 15n,
-      },
-      {
-        metadata: { name: "Test NFT 2" },
-        owner: null,
-        id: 1n,
-        tokenURI: "ipfs://QmV6gsfzdiMRtpnh8ay3CgutStVbes7qoF4DKpYE64h8hT/0",
-        type: "ERC1155",
-        supply: 5n,
-      },
-      {
-        metadata: {
-          name: "tw-contract-name",
-          symbol: "tw-contract-symbol",
-          description: "tw-contract-description",
-        },
-        owner: null,
-        id: 2n,
-        // Minted using URI from the test above
-        tokenURI:
-          "ipfs://bafybeiewg2e3vehsb5pb34xwk25eyyfwlvajzmgz3rtdrvn3upsxnsbhzi/contractUri.json",
-        type: "ERC1155",
-        supply: 1n,
-      },
-      {
-        metadata: { name: "batch token 0" },
-        owner: null,
-        id: 3n,
-        tokenURI: "ipfs://QmPSQhC2J6Wig4pH1Lt5th19FM58J5oukhfLfpc9L1i39Q/0",
-        type: "ERC1155",
-        supply: 1n,
-      },
-      {
-        metadata: { name: "batch token 1" },
-        owner: null,
-        id: 4n,
-        tokenURI: "ipfs://QmWRQwLBAeq6Wr65Yj7A4aeYqMD1C7Hs1moz15ncS6EhGu/0",
-        type: "ERC1155",
-        supply: 2n,
-      },
-      {
-        metadata: { name: "batch token 2" },
-        owner: null,
-        id: 5n,
-        tokenURI: "ipfs://QmTg1wxKGvdZR4NrdkYZGcfB5YYaBz75DH83td5RwprMRP/0",
-        type: "ERC1155",
-        supply: 3n,
-      },
-    ]);
+    const names = nfts.map((nft) => nft.metadata.name);
+    expect(names).toContain("batch token 0");
+    expect(names).toContain("batch token 1");
+    expect(names).toContain("batch token 2");
   });
 
   it("getOwnedTokenIds should work", async () => {

package/src/extensions/erc20/read/getCurrencyMetadata.test.ts

@@ -4,7 +4,7 @@ import { getCurrencyMetadata } from "./getCurrencyMetadata.js";
 
 describe("getCurrencyMetadata", () => {
   it("should throw if not a valid ERC20 contract", async () => {
-    await expect(() =>
+    await expect(
       getCurrencyMetadata({ contract: DOODLES_CONTRACT }),
     ).rejects.toThrowError("Invalid currency token");
   });

package/src/extensions/erc721/customDrop721.test.ts

@@ -65,19 +65,9 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       });
 
       await expect(nextTokenIdToMint({ contract })).resolves.toBe(6n);
-      await expect(
-        getNFT({ contract, tokenId: 0n }),
-      ).resolves.toMatchInlineSnapshot(`
-          {
-            "id": 0n,
-            "metadata": {
-              "name": "Test NFT",
-            },
-            "owner": null,
-            "tokenURI": "ipfs://QmTo68Dm1ntSp2BHLmE9gesS6ELuXosRz5mAgFCK6tfsRk/0",
-            "type": "ERC721",
-          }
-        `);
+      expect((await getNFT({ contract, tokenId: 0n })).metadata.name).toBe(
+        "Test NFT",
+      );
     });
 
     it("should allow to claim tokens", async () => {

package/src/extensions/erc721/drop721.test.ts

@@ -96,19 +96,9 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       });
 
       await expect(nextTokenIdToMint({ contract })).resolves.toBe(10n);
-      await expect(
-        getNFT({ contract, tokenId: 0n }),
-      ).resolves.toMatchInlineSnapshot(`
-        {
-          "id": 0n,
-          "metadata": {
-            "name": "Test NFT",
-          },
-          "owner": null,
-          "tokenURI": "ipfs://QmY1Rr4C7cYVPAaXykMMxg3AVbatDZ6Rd7u3gzt79CiDSB/0",
-          "type": "ERC721",
-        }
-      `);
+      expect((await getNFT({ contract, tokenId: 0n })).metadata.name).toBe(
+        "Test NFT",
+      );
     });
 
     it("should allow to claim tokens", async () => {

package/src/extensions/erc721/read/getNFT.ts

@@ -6,6 +6,7 @@ import {
   type TokenURIParams,
   tokenURI,
 } from "../__generated__/IERC721A/read/tokenURI.js";
+import { tokenByIndex } from "../__generated__/IERC721Enumerable/read/tokenByIndex.js";
 
 export { isTokenURISupported as isGetNFTSupported } from "../__generated__/IERC721A/read/tokenURI.js";
 
@@ -19,6 +20,13 @@ export type GetNFTParams = Prettify<
      * Whether to include the owner of the NFT.
      */
     includeOwner?: boolean;
+    /**
+     * Whether to check and fetch tokenID by index, in case of non-sequential IDs.
+     *
+     * It should be set to true if it's an ERC721Enumerable contract, and has `tokenByIndex` function.
+     * In this case, the provided tokenId will be considered as token-index and actual tokenId will be fetched from the contract.
+     */
+    tokenByIndex?: boolean;
   }
 >;
 
@@ -35,15 +43,37 @@ export type GetNFTParams = Prettify<
  *  tokenId: 1n,
  * });
  * ```
+ *
+ * * @example
+ * ```ts
+ * import { getNFT } from "thirdweb/extensions/erc721";
+ *
+ *
+ * const nft = await getNFT({
+ *  contract,
+ *  tokenId: 1n,
+ *  tokenByIndex: true // use this flag if the contract supports `tokenByIndex` and the above tokenId should be treated as an index.
+ * });
+ * ```
  */
 export async function getNFT(
   options: BaseTransactionOptions<GetNFTParams>,
 ): Promise<NFT> {
+  let tokenId = options.tokenId;
+  if (options.tokenByIndex) {
+    try {
+      tokenId = await tokenByIndex({
+        contract: options.contract,
+        index: options.tokenId,
+      });
+    } catch {}
+  }
+
   const [uri, owner] = await Promise.all([
-    tokenURI(options).catch(() => null),
+    tokenURI({ contract: options.contract, tokenId }).catch(() => null),
     options.includeOwner
       ? import("../__generated__/IERC721A/read/ownerOf.js")
-          .then((m) => m.ownerOf(options))
+          .then((m) => m.ownerOf({ contract: options.contract, tokenId }))
           .catch(() => null)
       : null,
   ]);
@@ -51,12 +81,12 @@ export async function getNFT(
   if (!uri?.trim()) {
     return parseNFT(
       {
-        id: options.tokenId,
+        id: tokenId,
         type: "ERC721",
         uri: "",
       },
       {
-        tokenId: options.tokenId,
+        tokenId,
         tokenUri: "",
         type: "ERC721",
         owner,
@@ -67,15 +97,15 @@ export async function getNFT(
   return parseNFT(
     await fetchTokenMetadata({
       client: options.contract.client,
-      tokenId: options.tokenId,
+      tokenId,
       tokenUri: uri,
     }).catch(() => ({
-      id: options.tokenId,
+      id: tokenId,
       type: "ERC721",
       uri,
     })),
     {
-      tokenId: options.tokenId,
+      tokenId: tokenId,
       tokenUri: uri,
       type: "ERC721",
       owner,

package/src/extensions/erc721/read/getNFTs.test.ts

@@ -189,7 +189,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("erc721.getNFTs", () => {
   });
 
   it("should throw error if totalSupply and nextTokenIdToMint are not supported", async () => {
-    await expect(() =>
+    await expect(
       getNFTs({ contract: UNISWAPV3_FACTORY_CONTRACT }),
     ).rejects.toThrowError(
       "Contract requires either `nextTokenIdToMint` or `totalSupply` function available to determine the next token ID to mint",

package/src/extensions/erc721/read/getNFTs.ts

@@ -34,6 +34,13 @@ export type GetNFTsParams = {
    * @default false
    */
   includeOwners?: boolean;
+  /**
+   * Whether to check and fetch tokenID by index, in case of non-sequential IDs.
+   *
+   * It should be set to true if it's an ERC721Enumerable contract, and has `tokenByIndex` function.
+   * In this case, the provided tokenId will be considered as token-index and actual tokenId will be fetched from the contract.
+   */
+  tokenByIndex?: boolean;
 };
 
 /**

package/src/extensions/erc721/read/getOwnedTokenIds.test.ts

@@ -22,7 +22,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("erc721.getOwnedTokenIds", () => {
   it("should throw if tokenOfOwnerByIndex or tokensOfOwner not supported", async () => {
     // We know current Lens contract on Polygon doesn't have this.
     const contract = UNISWAPV3_FACTORY_CONTRACT;
-    await expect(() =>
+    await expect(
       getOwnedTokenIds({ contract, owner: TEST_ACCOUNT_B.address }),
     ).rejects.toThrowError(
       `The contract at ${contract.address} on chain ${contract.chain.id} does not support the tokenOfOwnerByIndex or tokensOfOwner interface`,

package/src/extensions/lens/read/resolveAddress.test.ts

@@ -14,7 +14,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("resolve lens address", () => {
   });
 
   it("should throw if passed an invalid lens handle", async () => {
-    await expect(() =>
+    await expect(
       resolveAddress({ client: TEST_CLIENT, name: "vitalik.eth" }),
     ).rejects.toThrowError(
       "Could not fetch the wallet address for lens handle: vitalik.eth",

package/src/extensions/prebuilts/deploy-vote.test.ts

@@ -9,7 +9,7 @@ const account = TEST_ACCOUNT_B;
 
 describe.runIf(process.env.TW_SECRET_KEY)("deploy-voteERC20 contract", () => {
   it("should throw if passed an non-integer-like value to minVoteQuorumRequiredPercent", async () => {
-    await expect(() =>
+    await expect(
       deployVoteContract({
         account,
         client: TEST_CLIENT,

package/src/extensions/unstoppable-domains/read/resolveAddress.test.ts

@@ -19,7 +19,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
     });
 
     it("should throw an error with a non-existent domain name", async () => {
-      await expect(() =>
+      await expect(
         resolveAddress({
           name: "thirdwebsdk.thissuredoesnotexist",
           client: TEST_CLIENT,

package/src/extensions/unstoppable-domains/read/resolveName.test.ts

@@ -18,7 +18,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
     });
 
     it("should throw error on addresses that dont own any UD", async () => {
-      await expect(() =>
+      await expect(
         resolveName({ client: TEST_CLIENT, address: TEST_ACCOUNT_D.address }),
       ).rejects.toThrowError(
         `Failed to retrieve domain for address: ${TEST_ACCOUNT_D.address}. Make sure you have set the Reverse Resolution address for your domain at https://unstoppabledomains.com/manage?page=reverseResolution&domain=your-domain`,

package/src/gas/fee-data.ts

@@ -52,11 +52,13 @@ export async function getGasOverridesForTransaction(
   transaction: PreparedTransaction,
 ): Promise<FeeDataParams> {
   // first check for explicit values
-  const [maxFeePerGas, maxPriorityFeePerGas, gasPrice] = await Promise.all([
-    resolvePromisedValue(transaction.maxFeePerGas),
-    resolvePromisedValue(transaction.maxPriorityFeePerGas),
-    resolvePromisedValue(transaction.gasPrice),
-  ]);
+  const [maxFeePerGas, maxPriorityFeePerGas, gasPrice, type] =
+    await Promise.all([
+      resolvePromisedValue(transaction.maxFeePerGas),
+      resolvePromisedValue(transaction.maxPriorityFeePerGas),
+      resolvePromisedValue(transaction.gasPrice),
+      resolvePromisedValue(transaction.type),
+    ]);
 
   // Exit early if the user explicitly provided enough options
   if (maxFeePerGas !== undefined && maxPriorityFeePerGas !== undefined) {
@@ -65,6 +67,7 @@ export async function getGasOverridesForTransaction(
       maxPriorityFeePerGas,
     };
   }
+
   if (typeof gasPrice === "bigint") {
     return { gasPrice };
   }
@@ -73,6 +76,7 @@ export async function getGasOverridesForTransaction(
   const defaultGasOverrides = await getDefaultGasOverrides(
     transaction.client,
     transaction.chain,
+    type === "legacy" ? "legacy" : "eip1559", // 7702, 2930, and eip1559 all qualify as "eip1559" fee type
   );
 
   if (transaction.chain.experimental?.increaseZeroByteCount) {
@@ -103,6 +107,8 @@ export async function getGasOverridesForTransaction(
   };
 }
 
+export type FeeType = "legacy" | "eip1559";
+
 /**
  * Retrieves the default gas overrides for a given client and chain ID.
  * If the fee data contains both maxFeePerGas and maxPriorityFeePerGas, it returns an object with those values.
@@ -115,20 +121,27 @@ export async function getGasOverridesForTransaction(
 export async function getDefaultGasOverrides(
   client: ThirdwebClient,
   chain: Chain,
+  feeType?: FeeType,
 ) {
-  // if chain is in the force gas price list, always use gas price
-  if (!FORCE_GAS_PRICE_CHAIN_IDS.includes(chain.id)) {
-    const feeData = await getDynamicFeeData(client, chain);
-    if (
-      feeData.maxFeePerGas !== null &&
-      feeData.maxPriorityFeePerGas !== null
-    ) {
-      return {
-        maxFeePerGas: feeData.maxFeePerGas,
-        maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
-      };
-    }
+  // give priority to the transaction fee type over the chain fee type
+  const resolvedFeeType = feeType ?? chain.feeType;
+  // if chain is configured to force legacy transactions or is in the legacy chain list
+  if (
+    resolvedFeeType === "legacy" ||
+    FORCE_GAS_PRICE_CHAIN_IDS.includes(chain.id)
+  ) {
+    return {
+      gasPrice: await getGasPrice({ client, chain, percentMultiplier: 10 }),
+    };
+  }
+  const feeData = await getDynamicFeeData(client, chain);
+  if (feeData.maxFeePerGas !== null && feeData.maxPriorityFeePerGas !== null) {
+    return {
+      maxFeePerGas: feeData.maxFeePerGas,
+      maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
+    };
   }
+  // TODO: resolvedFeeType here could be "EIP1559", but we could not get EIP1559 fee data. should we throw?
   return {
     gasPrice: await getGasPrice({ client, chain, percentMultiplier: 10 }),
   };
@@ -156,7 +169,7 @@ async function getDynamicFeeData(
     eth_maxPriorityFeePerGas(rpcRequest).catch(() => null),
   ]);
 
-  const baseBlockFee = block?.baseFeePerGas ?? 0n;
+  const baseBlockFee = block?.baseFeePerGas;
 
   const chainId = chain.id;
   // flag chain testnet & flag chain
@@ -174,7 +187,7 @@ async function getDynamicFeeData(
     maxPriorityFeePerGas_ = maxPriorityFeePerGas;
   }
 
-  if (maxPriorityFeePerGas_ == null) {
+  if (maxPriorityFeePerGas_ == null || baseBlockFee == null) {
     // chain does not support eip-1559, return null for both
     return { maxFeePerGas: null, maxPriorityFeePerGas: null };
   }

package/src/pay/convert/cryptoToFiat.test.ts

@@ -52,7 +52,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("Pay: crypto-to-fiat", () => {
   });
 
   it("should throw error for testnet chain (because testnets are not supported", async () => {
-    await expect(() =>
+    await expect(
       convertCryptoToFiat({
         chain: sepolia,
         fromTokenAddress: NATIVE_TOKEN_ADDRESS,
@@ -66,7 +66,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("Pay: crypto-to-fiat", () => {
   });
 
   it("should throw error if fromTokenAddress is set to an invalid EVM address", async () => {
-    await expect(() =>
+    await expect(
       convertCryptoToFiat({
         chain: ethereum,
         fromTokenAddress: "haha",
@@ -80,7 +80,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("Pay: crypto-to-fiat", () => {
   });
 
   it("should throw error if fromTokenAddress is set to a wallet address", async () => {
-    await expect(() =>
+    await expect(
       convertCryptoToFiat({
         chain: base,
         fromTokenAddress: TEST_ACCOUNT_A.address,
@@ -99,7 +99,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("Pay: crypto-to-fiat", () => {
       status: 400,
       statusText: "Bad Request",
     });
-    await expect(() =>
+    await expect(
       convertCryptoToFiat({
         chain: base,
         fromTokenAddress: NATIVE_TOKEN_ADDRESS,