[SDK] Improve test coverage for ERC20 extensions (#4963)

## Problem solved

Short description of the bug fixed or feature added

<!-- start pr-codex -->

---

## PR-Codex overview
This PR focuses on adding unit tests for various functionalities related to ERC20 contracts, including metadata retrieval, contract validation, and batch token transfers.

### Detailed summary
- Added tests for `getCurrencyMetadata` to validate ERC20 contracts and return correct metadata.
- Implemented tests for `isERC20` to check contract validity against USDT, USDC, and an NFT contract.
- Created tests for `transferBatch` to verify token transfers to multiple recipients.

> ✨ Ask PR-Codex anything about this PR by commenting with `/codex {your question}`

<!-- end pr-codex -->

Author: kien-ngo

packages/thirdweb/src/extensions/erc20/read/getCurrencyMetadata.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { DOODLES_CONTRACT, USDT_CONTRACT } from "~test/test-contracts.js";
+import { getCurrencyMetadata } from "./getCurrencyMetadata.js";
+
+describe("getCurrencyMetadata", () => {
+  it("should throw if not a valid ERC20 contract", async () => {
+    await expect(() =>
+      getCurrencyMetadata({ contract: DOODLES_CONTRACT }),
+    ).rejects.toThrowError("Invalid currency token");
+  });
+
+  it("should return valid result if the contract is ERC20", async () => {
+    const result = await getCurrencyMetadata({ contract: USDT_CONTRACT });
+    expect(result).toStrictEqual({
+      name: "Tether USD",
+      symbol: "USDT",
+      decimals: 6,
+    });
+  });
+});

packages/thirdweb/src/extensions/erc20/read/isERC20.test.ts

@@ -0,0 +1,35 @@
+import { type Abi, toFunctionSelector } from "viem";
+import { describe, expect, it } from "vitest";
+import {
+  BASE_USDC_PROXY_CONTRACT,
+  DOODLES_CONTRACT,
+  USDT_CONTRACT,
+} from "~test/test-contracts.js";
+import { resolveContractAbi } from "../../../contract/actions/resolve-abi.js";
+import { isERC20 } from "./isERC20.js";
+
+describe("isERC20", () => {
+  it("should detect USDT as a valid erc20 contract", async () => {
+    const abi = await resolveContractAbi<Abi>(USDT_CONTRACT);
+    const selectors = abi
+      .filter((f) => f.type === "function")
+      .map((f) => toFunctionSelector(f));
+    expect(isERC20(selectors)).toBe(true);
+  });
+
+  it("should detect USDC as a valid erc20 contract", async () => {
+    const abi = await resolveContractAbi<Abi>(BASE_USDC_PROXY_CONTRACT);
+    const selectors = abi
+      .filter((f) => f.type === "function")
+      .map((f) => toFunctionSelector(f));
+    expect(isERC20(selectors)).toBe(true);
+  });
+
+  it("should NOT detect any NFT contract as a valid erc20 contract", async () => {
+    const abi = await resolveContractAbi<Abi>(DOODLES_CONTRACT);
+    const selectors = abi
+      .filter((f) => f.type === "function")
+      .map((f) => toFunctionSelector(f));
+    expect(isERC20(selectors)).toBe(false);
+  });
+});

packages/thirdweb/src/extensions/erc20/write/transferBatch.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from "vitest";
+import { ANVIL_CHAIN } from "~test/chains.js";
+import { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import {
+  TEST_ACCOUNT_A,
+  TEST_ACCOUNT_B,
+  TEST_ACCOUNT_C,
+  TEST_ACCOUNT_D,
+} from "~test/test-wallets.js";
+import { getContract } from "../../../contract/contract.js";
+import { deployERC20Contract } from "../../../extensions/prebuilts/deploy-erc20.js";
+import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
+import { balanceOf } from "../__generated__/IERC20/read/balanceOf.js";
+import { mintTo } from "./mintTo.js";
+import { transferBatch } from "./transferBatch.js";
+
+const chain = ANVIL_CHAIN;
+const client = TEST_CLIENT;
+const account = TEST_ACCOUNT_A;
+
+describe("erc20: transferBatch", () => {
+  it("should transfer tokens to multiple recipients", async () => {
+    const address = await deployERC20Contract({
+      type: "TokenERC20",
+      account,
+      chain,
+      client,
+      params: {
+        name: "",
+        contractURI: TEST_CONTRACT_URI,
+      },
+    });
+    const contract = getContract({
+      address,
+      chain,
+      client,
+    });
+
+    // Mint 100 tokens
+    await sendAndConfirmTransaction({
+      transaction: mintTo({ contract, to: account.address, amount: 100 }),
+      account,
+    });
+
+    // Send 25 tokens to each account B, C and D
+    await sendAndConfirmTransaction({
+      account,
+      transaction: transferBatch({
+        contract,
+        batch: [
+          {
+            to: TEST_ACCOUNT_B.address,
+            amount: 25,
+          },
+          {
+            to: TEST_ACCOUNT_C.address,
+            amount: 25,
+          },
+          {
+            to: TEST_ACCOUNT_D.address,
+            amount: 25,
+          },
+        ],
+      }),
+    });
+
+    // After that, each address A, B, C and D should have 25 tokens
+    const [balanceA, balanceB, balanceC, balanceD] = await Promise.all([
+      balanceOf({ contract, address: TEST_ACCOUNT_A.address }),
+      balanceOf({ contract, address: TEST_ACCOUNT_B.address }),
+      balanceOf({ contract, address: TEST_ACCOUNT_C.address }),
+      balanceOf({ contract, address: TEST_ACCOUNT_D.address }),
+    ]);
+
+    expect(balanceA).toBe(25n * 10n ** 18n);
+    expect(balanceB).toBe(25n * 10n ** 18n);
+    expect(balanceC).toBe(25n * 10n ** 18n);
+    expect(balanceD).toBe(25n * 10n ** 18n);
+  });
+});