thirdweb 5.80.1-nightly-a7b6cb3211e8b5232e77965cb8dd8ff96b369424-20241228000338 → 5.80.1-nightly-03bf859809de255d20f4ed8285a3bb75cef17252-20241229000354

package/dist/types/utils/url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../src/utils/url.ts"],"names":[],"mappings":"AAOA,KAAK,aAAa,GAAG;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA4CF;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,aAAa,CAIf;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAEtE;AAED,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,UAE5E"}
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../src/utils/url.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,WAEpC;AAED,KAAK,aAAa,GAAG;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,aAAa,CAcf;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,CAkB5E;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,aAAa,CAIf;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAEtE;AAED,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,UAE5E"}

package/dist/types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "5.80.1-nightly-a7b6cb3211e8b5232e77965cb8dd8ff96b369424-20241228000338";
+export declare const version = "5.80.1-nightly-03bf859809de255d20f4ed8285a3bb75cef17252-20241229000354";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thirdweb",
-  "version": "5.80.1-nightly-a7b6cb3211e8b5232e77965cb8dd8ff96b369424-20241228000338",
+  "version": "5.80.1-nightly-03bf859809de255d20f4ed8285a3bb75cef17252-20241229000354",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/thirdweb-dev/js.git#main"

package/src/auth/verify-hash.test.ts

@@ -16,7 +16,7 @@ describe("verifyHash", async () => {
         privateKey: ANVIL_PKEY_A,
       });
 
-      expect(
+      await expect(
         verifyHash({
           address: TEST_ACCOUNT_A.address,
           hash: hashMessage("hello world"),
@@ -33,7 +33,7 @@ describe("verifyHash", async () => {
         privateKey: ANVIL_PKEY_A,
       });
 
-      expect(
+      await expect(
         verifyHash({
           address: TEST_ACCOUNT_A.address,
           hash: hashMessage("hello world"),
@@ -50,7 +50,7 @@ describe("verifyHash", async () => {
         privateKey: ANVIL_PKEY_A,
       });
 
-      expect(
+      await expect(
         verifyHash({
           address: TEST_ACCOUNT_A.address,
           hash: hashMessage("hello world"),

package/src/chains/utils.test.ts

@@ -9,12 +9,15 @@ import { toSerializableTransaction } from "../transaction/actions/to-serializabl
 import { privateKeyToAccount } from "../wallets/private-key.js";
 import { avalanche } from "./chain-definitions/avalanche.js";
 import { ethereum } from "./chain-definitions/ethereum.js";
-import type { LegacyChain } from "./types.js";
+import type { ChainMetadata, LegacyChain } from "./types.js";
 
+import { base } from "viem/chains";
 import {
   CUSTOM_CHAIN_MAP,
   cacheChains,
+  convertApiChainToChain,
   convertLegacyChain,
+  convertViemChain,
   defineChain,
   getCachedChain,
   getChainDecimals,
@@ -237,4 +240,70 @@ describe("defineChain", () => {
     cacheChains([scroll]);
     expect(CUSTOM_CHAIN_MAP.get(scroll.id)).toStrictEqual(scroll);
   });
+
+  it("Chain converted from viem should have the blockExplorers being an array", () => {
+    expect(Array.isArray(convertViemChain(base).blockExplorers)).toBe(true);
+  });
+
+  it("convertApiChainToChain should work", () => {
+    const ethChain: ChainMetadata = {
+      chainId: 1,
+      name: "Ethereum Mainnet",
+      chain: "ETH",
+      shortName: "eth",
+      icon: {
+        url: "ipfs://QmcxZHpyJa8T4i63xqjPYrZ6tKrt55tZJpbXcjSDKuKaf9/ethereum/512.png",
+        width: 512,
+        height: 512,
+        format: "png",
+      },
+      nativeCurrency: {
+        name: "Ether",
+        symbol: "ETH",
+        decimals: 18,
+      },
+      ens: {
+        registry: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
+      },
+      explorers: [
+        {
+          name: "etherscan",
+          url: "https://etherscan.io",
+          standard: "EIP3091",
+        },
+      ],
+      rpc: ["https://1.rpc.thirdweb.com/${THIRDWEB_API_KEY}"],
+      testnet: false,
+      infoURL: "https://ethereum.org",
+      slug: "ethereum",
+      networkId: 1,
+      stackType: "l1",
+    };
+
+    expect(convertApiChainToChain(ethChain)).toStrictEqual({
+      blockExplorers: [
+        {
+          apiUrl: "https://etherscan.io",
+          name: "etherscan",
+          url: "https://etherscan.io",
+        },
+      ],
+      faucets: undefined,
+      icon: {
+        format: "png",
+        height: 512,
+        url: "ipfs://QmcxZHpyJa8T4i63xqjPYrZ6tKrt55tZJpbXcjSDKuKaf9/ethereum/512.png",
+        width: 512,
+      },
+      id: 1,
+      name: "Ethereum Mainnet",
+      nativeCurrency: {
+        decimals: 18,
+        name: "Ether",
+        symbol: "ETH",
+      },
+      rpc: "https://1.rpc.thirdweb.com/${THIRDWEB_API_KEY}",
+      testnet: undefined,
+    });
+  });
 });

package/src/chains/utils.ts

@@ -132,7 +132,10 @@ function isViemChain(
   return "rpcUrls" in chain && !("rpc" in chain);
 }
 
-function convertViemChain(viemChain: ViemChain): Chain {
+/**
+ * @internal
+ */
+export function convertViemChain(viemChain: ViemChain): Chain {
   const RPC_URL = getThirdwebDomains().rpc;
   return {
     id: viemChain.id,

package/src/contract/contract.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { USDT_CONTRACT_ADDRESS } from "~test/test-contracts.js";
+import { ethereum } from "../chains/chain-definitions/ethereum.js";
+import { getContract } from "./contract.js";
+
+describe("Contract - getContract", () => {
+  it("should throw error if client is not passed", () => {
+    expect(() =>
+      // @ts-ignore Test purpose
+      getContract({ address: "0x", chain: ethereum }),
+    ).toThrowError(
+      `getContract validation error - invalid client: ${undefined}`,
+    );
+  });
+
+  it("should throw error if address is not valid", () => {
+    expect(() =>
+      getContract({ address: "0x", chain: ethereum, client: TEST_CLIENT }),
+    ).toThrowError("getContract validation error - invalid address: 0x");
+  });
+
+  it("should throw error if chain is not passed", () => {
+    expect(() =>
+      // @ts-ignore Test purpose
+      getContract({ address: USDT_CONTRACT_ADDRESS, client: TEST_CLIENT }),
+    ).toThrowError(
+      `getContract validation error - invalid chain: ${undefined}`,
+    );
+  });
+
+  it("should throw error if chain doesn't have id", () => {
+    expect(() =>
+      getContract({
+        address: USDT_CONTRACT_ADDRESS,
+        client: TEST_CLIENT,
+        // @ts-ignore Test
+        chain: {},
+      }),
+    ).toThrowError(`getContract validation error - invalid chain: ${{}}`);
+  });
+});

package/src/exports/utils.ts

@@ -1,7 +1,7 @@
 // bytecode
 export { detectMethod } from "../utils/bytecode/detectExtension.js";
 export { extractIPFSUri } from "../utils/bytecode/extractIPFS.js";
-export { extractMinimalProxyImplementationAddress } from "../utils/bytecode/extractMnimalProxyImplementationAddress.js";
+export { extractMinimalProxyImplementationAddress } from "../utils/bytecode/extractMinimalProxyImplementationAddress.js";
 export { isContractDeployed } from "../utils/bytecode/is-contract-deployed.js";
 export { ensureBytecodePrefix } from "../utils/bytecode/prefix.js";
 export { resolveImplementation } from "../utils/bytecode/resolveImplementation.js";

package/src/extensions/thirdweb/write/publish.test.ts

@@ -105,7 +105,7 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential("publishContract", () => {
 
     expect(publishedContracts.length).toBe(1);
 
-    expect(
+    await expect(
       sendAndConfirmTransaction({
         account: TEST_ACCOUNT_D,
         transaction: publishContract({

package/src/react/web/ui/ConnectWallet/screens/Buy/fiat/currencies.test.tsx

@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import { CADIcon } from "../../../icons/currencies/CADIcon.js";
+import { EURIcon } from "../../../icons/currencies/EURIcon.js";
+import { GBPIcon } from "../../../icons/currencies/GBPIcon.js";
+import { JPYIcon } from "../../../icons/currencies/JPYIcon.js";
+import { USDIcon } from "../../../icons/currencies/USDIcon.js";
+import { currencies, getCurrencyMeta, usdCurrency } from "./currencies.js";
+
+describe("Currency Utilities", () => {
+  it("should have correct number of currencies", () => {
+    expect(currencies.length).toBe(5);
+  });
+
+  it("should have USD as the first currency", () => {
+    expect(currencies[0]).toEqual(usdCurrency);
+  });
+
+  it("should have correct properties for each currency", () => {
+    for (const currency of currencies) {
+      expect(currency).toHaveProperty("shorthand");
+      expect(currency).toHaveProperty("name");
+      expect(currency).toHaveProperty("icon");
+    }
+  });
+
+  describe("getCurrencyMeta function", () => {
+    it("should return correct currency meta for valid shorthand", () => {
+      const cadMeta = getCurrencyMeta("CAD");
+      expect(cadMeta.shorthand).toBe("CAD");
+      expect(cadMeta.name).toBe("Canadian Dollar");
+      expect(cadMeta.icon).toBe(CADIcon);
+    });
+
+    it("should be case-insensitive", () => {
+      const eurMeta = getCurrencyMeta("eur");
+      expect(eurMeta.shorthand).toBe("EUR");
+      expect(eurMeta.name).toBe("Euro");
+      expect(eurMeta.icon).toBe(EURIcon);
+    });
+
+    it("should return unknown currency for invalid shorthand", () => {
+      const unknownMeta = getCurrencyMeta("XYZ");
+      expect(unknownMeta.shorthand).toBe("XYZ");
+      expect(unknownMeta.name).toBe("XYZ");
+      expect(unknownMeta.icon).not.toBe(USDIcon);
+      expect(unknownMeta.icon).not.toBe(CADIcon);
+      expect(unknownMeta.icon).not.toBe(GBPIcon);
+      expect(unknownMeta.icon).not.toBe(EURIcon);
+      expect(unknownMeta.icon).not.toBe(JPYIcon);
+    });
+  });
+});

package/src/react/web/ui/ConnectWallet/screens/Buy/pay-transactions/statusMeta.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, it } from "vitest";
+import type { BuyWithCryptoStatus } from "../../../../../../../pay/buyWithCrypto/getStatus.js";
+import type { BuyWithFiatStatus } from "../../../../../../../pay/buyWithFiat/getStatus.js";
+import {
+  getBuyWithCryptoStatusMeta,
+  getBuyWithFiatStatusMeta,
+} from "./statusMeta.js";
+
+describe("getBuyWithCryptoStatusMeta", () => {
+  it('returns "Unknown" for NOT_FOUND status', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      status: "NOT_FOUND",
+    } as BuyWithCryptoStatus);
+    expect(result).toEqual({
+      status: "Unknown",
+      color: "secondaryText",
+    });
+  });
+
+  it('returns "Bridging" for WAITING_BRIDGE subStatus', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      status: "PENDING",
+      subStatus: "WAITING_BRIDGE",
+    } as BuyWithCryptoStatus);
+    expect(result).toEqual({
+      status: "Bridging",
+      color: "accentText",
+      loading: true,
+    });
+  });
+
+  it('returns "Incomplete" for PARTIAL_SUCCESS subStatus', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      status: "COMPLETED",
+      subStatus: "PARTIAL_SUCCESS",
+    } as BuyWithCryptoStatus);
+    expect(result).toEqual({
+      status: "Incomplete",
+      color: "secondaryText",
+    });
+  });
+
+  it('returns "Pending" for PENDING status', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      status: "PENDING",
+    } as BuyWithCryptoStatus);
+    expect(result).toEqual({
+      status: "Pending",
+      color: "accentText",
+      loading: true,
+    });
+  });
+
+  it('returns "Failed" for FAILED status', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      status: "FAILED",
+    } as BuyWithCryptoStatus);
+    expect(result).toEqual({
+      status: "Failed",
+      color: "danger",
+    });
+  });
+
+  it('returns "Completed" for COMPLETED status', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      status: "COMPLETED",
+    } as BuyWithCryptoStatus);
+    expect(result).toEqual({
+      status: "Completed",
+      color: "success",
+    });
+  });
+
+  it('returns "Unknown" for unhandled status', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      // @ts-ignore Test purpose
+      status: "Unknown",
+    });
+    expect(result).toEqual({
+      status: "Unknown",
+      color: "secondaryText",
+    });
+  });
+});
+
+describe("getBuyWithFiatStatusMeta", () => {
+  it('returns "Incomplete" for CRYPTO_SWAP_FALLBACK status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      status: "CRYPTO_SWAP_FALLBACK",
+    } as BuyWithFiatStatus);
+    expect(result).toEqual({
+      status: "Incomplete",
+      color: "danger",
+      step: 2,
+      progressStatus: "partialSuccess",
+    });
+  });
+
+  it('returns "Pending" for CRYPTO_SWAP_IN_PROGRESS status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      status: "CRYPTO_SWAP_IN_PROGRESS",
+    } as BuyWithFiatStatus);
+    expect(result).toEqual({
+      status: "Pending",
+      color: "accentText",
+      loading: true,
+      step: 2,
+      progressStatus: "pending",
+    });
+  });
+
+  it('returns "Pending" for PENDING_ON_RAMP_TRANSFER status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      status: "PENDING_ON_RAMP_TRANSFER",
+    } as BuyWithFiatStatus);
+    expect(result).toEqual({
+      status: "Pending",
+      color: "accentText",
+      loading: true,
+      step: 1,
+      progressStatus: "pending",
+    });
+  });
+
+  it('returns "Completed" for ON_RAMP_TRANSFER_COMPLETED status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      status: "ON_RAMP_TRANSFER_COMPLETED",
+    } as BuyWithFiatStatus);
+    expect(result).toEqual({
+      status: "Completed",
+      color: "success",
+      loading: true,
+      step: 1,
+      progressStatus: "completed",
+    });
+  });
+
+  it('returns "Action Required" for CRYPTO_SWAP_REQUIRED status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      status: "CRYPTO_SWAP_REQUIRED",
+    } as BuyWithFiatStatus);
+    expect(result).toEqual({
+      status: "Action Required",
+      color: "accentText",
+      step: 2,
+      progressStatus: "actionRequired",
+    });
+  });
+
+  it('returns "Failed" for PAYMENT_FAILED status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      status: "PAYMENT_FAILED",
+    } as BuyWithFiatStatus);
+    expect(result).toEqual({
+      status: "Failed",
+      color: "danger",
+      step: 1,
+      progressStatus: "failed",
+    });
+  });
+
+  it('returns "Unknown" for unhandled status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      // @ts-ignore
+      status: "UNKNOWN_STATUS",
+    });
+    expect(result).toEqual({
+      status: "Unknown",
+      color: "secondaryText",
+      step: 1,
+      progressStatus: "unknown",
+    });
+  });
+});

package/src/react/web/ui/ConnectWallet/screens/Buy/swap/formatSeconds.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { formatSeconds } from "./formatSeconds.js";
+
+describe("formatSeconds", () => {
+  it("formats seconds to hours and minutes when over 3600 seconds", () => {
+    expect(formatSeconds(3601)).toBe("1 Hours 0 Minutes");
+    expect(formatSeconds(7200)).toBe("2 Hours 0 Minutes");
+    expect(formatSeconds(5400)).toBe("1 Hours 30 Minutes");
+    expect(formatSeconds(12345)).toBe("3 Hours 25 Minutes");
+  });
+
+  it("formats seconds to minutes when between 61 and 3600 seconds", () => {
+    expect(formatSeconds(61)).toBe("2 Minutes");
+    expect(formatSeconds(120)).toBe("2 Minutes");
+    expect(formatSeconds(3599)).toBe("60 Minutes");
+    expect(formatSeconds(1800)).toBe("30 Minutes");
+  });
+
+  it('formats seconds to "Xs" when 60 seconds or less', () => {
+    expect(formatSeconds(60)).toBe("60s");
+    expect(formatSeconds(59)).toBe("59s");
+    expect(formatSeconds(1)).toBe("1s");
+    expect(formatSeconds(0)).toBe("0s");
+  });
+
+  it("handles decimal inputs by rounding down for hours/minutes and up for minutes only", () => {
+    expect(formatSeconds(3661.5)).toBe("1 Hours 1 Minutes");
+    expect(formatSeconds(119.9)).toBe("2 Minutes");
+  });
+});

package/src/react/web/ui/ConnectWallet/screens/Buy/utils.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { getBuyTokenAmountFontSize } from "./utils.js";
+
+describe("getBuyTokenAmountFontSize", () => {
+  it("returns 26px for strings longer than 10 characters", () => {
+    expect(getBuyTokenAmountFontSize("12345678901")).toBe("26px");
+    expect(getBuyTokenAmountFontSize("1234567890123")).toBe("26px");
+  });
+
+  it("returns 34px for strings longer than 6 characters but not more than 10", () => {
+    expect(getBuyTokenAmountFontSize("1234567")).toBe("34px");
+    expect(getBuyTokenAmountFontSize("1234567890")).toBe("34px");
+  });
+
+  it("returns 50px for strings 6 characters or shorter", () => {
+    expect(getBuyTokenAmountFontSize("123456")).toBe("50px");
+    expect(getBuyTokenAmountFontSize("12345")).toBe("50px");
+    expect(getBuyTokenAmountFontSize("")).toBe("50px");
+  });
+});

package/src/react/web/wallets/injected/locale/getInjectedWalletLocale.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import type { LocaleId } from "../../../../../react/web/ui/types.js";
+import br from "./br.js";
+import de from "./de.js";
+import en from "./en.js";
+import es from "./es.js";
+import fr from "./fr.js";
+import { getInjectedWalletLocale } from "./getInjectedWalletLocale.js";
+import ja from "./ja.js";
+import kr from "./kr.js";
+import tl from "./tl.js";
+import vi from "./vi.js";
+
+const locales: { locale: LocaleId; content: object }[] = [
+  { locale: "es_ES", content: es },
+  { locale: "ja_JP", content: ja },
+  { locale: "tl_PH", content: tl },
+  { locale: "vi_VN", content: vi },
+  { locale: "de_DE", content: de },
+  { locale: "ko_KR", content: kr },
+  { locale: "fr_FR", content: fr },
+  { locale: "pt_BR", content: br },
+];
+
+describe("getInjectedWalletLocale", () => {
+  for (const item of locales) {
+    it(`should return the correct locale structure for ${item.locale}`, async () => {
+      expect(await getInjectedWalletLocale(item.locale)).toStrictEqual(
+        item.content,
+      );
+    });
+  }
+
+  it("should return the default locale being ENGLISH for an unsupported locale", async () => {
+    expect(
+      await getInjectedWalletLocale("unsupported_locale" as LocaleId),
+    ).toBe(en);
+  });
+});

package/src/react/web/wallets/smartWallet/locale/getSmartWalletLocale.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import type { LocaleId } from "../../../../../react/web/ui/types.js";
+import br from "./br.js";
+import de from "./de.js";
+import en from "./en.js";
+import es from "./es.js";
+import fr from "./fr.js";
+import { getSmartWalletLocale } from "./getSmartWalletLocale.js";
+import ja from "./ja.js";
+import kr from "./kr.js";
+import tl from "./tl.js";
+import vi from "./vi.js";
+
+const locales: { locale: LocaleId; content: object }[] = [
+  { locale: "es_ES", content: es },
+  { locale: "ja_JP", content: ja },
+  { locale: "tl_PH", content: tl },
+  { locale: "vi_VN", content: vi },
+  { locale: "de_DE", content: de },
+  { locale: "ko_KR", content: kr },
+  { locale: "fr_FR", content: fr },
+  { locale: "pt_BR", content: br },
+];
+
+describe("getInjectedWalletLocale", () => {
+  for (const item of locales) {
+    it(`should return the correct locale structure for ${item.locale}`, async () => {
+      expect(await getSmartWalletLocale(item.locale)).toStrictEqual(
+        item.content,
+      );
+    });
+  }
+
+  it("should return the default locale being ENGLISH for an unsupported locale", async () => {
+    expect(await getSmartWalletLocale("unsupported_locale" as LocaleId)).toBe(
+      en,
+    );
+  });
+});

package/src/utils/abi/normalizeFunctionParams.test.ts

@@ -0,0 +1,108 @@
+import type { AbiFunction } from "abitype";
+import { describe, expect, it, vi } from "vitest";
+import { parseAbiParams } from "../contract/parse-abi-params.js";
+import { normalizeFunctionParams } from "./normalizeFunctionParams.js";
+
+vi.mock("../contract/parse-abi-params.js", () => {
+  return {
+    parseAbiParams: vi.fn((_types, values) => values),
+  };
+});
+
+describe("normalizeFunctionParams", () => {
+  it("should return an empty array when abiFunction is undefined", () => {
+    const result = normalizeFunctionParams(undefined, {});
+    expect(result).toEqual([]);
+  });
+
+  it("should normalize and return function parameters correctly", () => {
+    const abiFunction: AbiFunction = {
+      inputs: [
+        { name: "_param1", type: "uint256" },
+        { name: "_param2", type: "string" },
+      ],
+      type: "function",
+      stateMutability: "pure",
+      name: "test",
+      outputs: [],
+    };
+    const params = {
+      param1: 123,
+      param2: "hello",
+    };
+
+    const result = normalizeFunctionParams(abiFunction, params);
+    expect(result).toEqual([123, "hello"]);
+  });
+
+  it("should handle parameter names with underscores", () => {
+    const abiFunction: AbiFunction = {
+      inputs: [
+        { name: "_param1", type: "uint256" },
+        { name: "_param2", type: "string" },
+      ],
+      type: "function",
+      stateMutability: "pure",
+      name: "test",
+      outputs: [],
+    };
+    const params = {
+      _param1: 123,
+      param2: "hello",
+    };
+
+    const result = normalizeFunctionParams(abiFunction, params);
+    expect(result).toEqual([123, "hello"]);
+  });
+
+  it("should throw an error if a parameter name is missing", () => {
+    const abiFunction: AbiFunction = {
+      inputs: [{ name: undefined, type: "uint256" }],
+      type: "function",
+      stateMutability: "pure",
+      name: "test",
+      outputs: [],
+    };
+
+    expect(() => normalizeFunctionParams(abiFunction, {})).toThrow(
+      "Missing named parameter for test at index 0",
+    );
+  });
+
+  it("should throw an error if a parameter value is missing", () => {
+    const abiFunction: AbiFunction = {
+      inputs: [{ name: "_param1", type: "uint256" }],
+      name: "testFunction",
+      type: "function",
+      stateMutability: "pure",
+      outputs: [],
+    };
+
+    expect(() => normalizeFunctionParams(abiFunction, {})).toThrow(
+      "Missing value for parameter _param1 at index 0",
+    );
+  });
+
+  it("should call parseAbiParams with the correct arguments", () => {
+    const abiFunction: AbiFunction = {
+      inputs: [
+        { name: "_param1", type: "uint256" },
+        { name: "_param2", type: "string" },
+      ],
+      type: "function",
+      stateMutability: "pure",
+      name: "test",
+      outputs: [],
+    };
+    const params = {
+      param1: 123,
+      param2: "hello",
+    };
+
+    normalizeFunctionParams(abiFunction, params);
+    expect(parseAbiParams).toHaveBeenCalledWith(
+      ["uint256", "string"],
+      [123, "hello"],
+    );
+  });
+});