thirdweb 5.83.2-nightly-332536bdee05b6fb3b36d33761381826279b48f6-20250113000321 → 5.84.0

package/src/utils/ens/isValidENSName.ts

@@ -0,0 +1,54 @@
+// modified version of isFQDN from validator.js that checks if given string is a valid domain name
+// https://github.com/validatorjs/validator.js/blob/master/src/lib/isFQDN.js
+// underscores are allowed, hyphens are allowed, no max length check
+
+/**
+ * Checks if a string is a valid ENS name.
+ * It does not check if the ENS name is currently registered or resolves to an address - it only validates the string format.
+ *
+ * @param name - The ENS name to check.
+ *
+ * @example
+ * ```ts
+ * isValidENSName("thirdweb.eth"); // true
+ * isValidENSName("foo.bar.com"); // true
+ * isValidENSName("xyz"); // false
+ */
+export function isValidENSName(name: string) {
+  const parts = name.split(".");
+  const tld = parts[parts.length - 1];
+
+  // disallow fqdns without tld
+  if (parts.length < 2 || !tld) {
+    return false;
+  }
+
+  // disallow spaces
+  if (/\s/.test(tld)) {
+    return false;
+  }
+
+  // reject numeric TLDs
+  if (/^\d+$/.test(tld)) {
+    return false;
+  }
+
+  return parts.every((part) => {
+    // part must be at least 1 char long
+    if (part.length < 1) {
+      return false;
+    }
+
+    // disallow invalid chars
+    if (!/^[a-z_\u00a1-\uffff0-9-]+$/i.test(part)) {
+      return false;
+    }
+
+    // disallow full-width chars
+    if (/[\uff01-\uff5e]/.test(part)) {
+      return false;
+    }
+
+    return true;
+  });
+}

package/src/utils/extensions/drops/convert-quantity.ts

@@ -1,4 +1,4 @@
-import { maxUint256 } from "viem";
+import { maxUint256 } from "ox/Solidity";
 import { toUnits } from "../../units.js";
 
 export function convertQuantity(options: {

package/src/utils/extensions/drops/get-multicall-set-claim-claim-conditon-transactions.ts

@@ -1,4 +1,4 @@
-import { maxUint256 } from "viem";
+import { maxUint256 } from "ox/Solidity";
 import { NATIVE_TOKEN_ADDRESS } from "../../../constants/addresses.js";
 import type { ThirdwebContract } from "../../../contract/contract.js";
 import type { SetClaimConditionsParams as GeneratedParams } from "../../../extensions/erc1155/__generated__/IDrop1155/write/setClaimConditions.js";

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.83.2-nightly-332536bdee05b6fb3b36d33761381826279b48f6-20250113000321";
+export const version = "5.84.0";

package/src/wallets/connection/autoConnect.test.ts

@@ -0,0 +1,67 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { TEST_ACCOUNT_A } from "~test/test-wallets.js";
+import { createWalletAdapter } from "../../adapters/wallet-adapter.js";
+import { ethereum } from "../../chains/chain-definitions/ethereum.js";
+import { webLocalStorage } from "../../utils/storage/webStorage.js";
+import { createWallet } from "../create-wallet.js";
+import { getInstalledWalletProviders } from "../injected/mipdStore.js";
+import { autoConnect } from "./autoConnect.js";
+import { autoConnectCore } from "./autoConnectCore.js";
+
+vi.mock("../../utils/storage/webStorage.js");
+vi.mock("../create-wallet.js");
+vi.mock("../injected/mipdStore.js");
+vi.mock("./autoConnectCore.js");
+
+describe("autoConnect", () => {
+  const mockWallet = createWalletAdapter({
+    adaptedAccount: TEST_ACCOUNT_A,
+    client: TEST_CLIENT,
+    chain: ethereum,
+    onDisconnect: () => {},
+    switchChain: () => {},
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(getInstalledWalletProviders).mockReturnValue([]);
+    vi.mocked(createWallet).mockReturnValue(mockWallet);
+    vi.mocked(autoConnectCore).mockResolvedValue(true);
+  });
+
+  it("should call autoConnectCore with correct parameters when wallets are provided", async () => {
+    const result = await autoConnect({
+      client: TEST_CLIENT,
+      wallets: [mockWallet],
+    });
+
+    expect(autoConnectCore).toHaveBeenCalledWith({
+      storage: webLocalStorage,
+      props: {
+        client: TEST_CLIENT,
+        wallets: [mockWallet],
+      },
+      createWalletFn: createWallet,
+      getInstalledWallets: expect.any(Function),
+      manager: expect.any(Object),
+    });
+    expect(result).toBe(true);
+  });
+
+  it("should use default wallets when no wallets are provided", async () => {
+    await autoConnect({
+      wallets: [],
+      client: TEST_CLIENT,
+    });
+
+    expect(autoConnectCore).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: {
+          client: TEST_CLIENT,
+          wallets: [],
+        },
+      }),
+    );
+  });
+});

package/src/wallets/connection/autoConnect.ts

@@ -0,0 +1,58 @@
+import { webLocalStorage } from "../../utils/storage/webStorage.js";
+import { createWallet } from "../create-wallet.js";
+import { getDefaultWallets } from "../defaultWallets.js";
+import { getInstalledWalletProviders } from "../injected/mipdStore.js";
+import type { Wallet } from "../interfaces/wallet.js";
+import { createConnectionManager } from "../manager/index.js";
+import { autoConnectCore } from "./autoConnectCore.js";
+import type { AutoConnectProps } from "./types.js";
+
+/**
+ * Attempts to automatically connect to the last connected wallet.
+ * It combines both specified wallets and installed wallet providers that aren't already specified.
+ *
+ * @example
+ *
+ * ```tsx
+ * import { autoConnect } from "thirdweb/wallets";
+ *
+ * const autoConnected = await autoConnect({
+ *  client,
+ *  onConnect: (wallet) => {
+ *    console.log("wallet", wallet);
+ *  },
+ * });
+ * ```
+ *
+ * @param props - The auto-connect configuration properties
+ * @param props.wallets - Array of wallet instances to consider for auto-connection
+ * @returns {boolean} a promise resolving to true or false depending on whether the auto connect function connected to a wallet or not
+ */
+export const autoConnect = async (
+  props: AutoConnectProps & {
+    wallets?: Wallet[];
+  },
+) => {
+  const wallets = props.wallets || getDefaultWallets(props);
+  const manager = createConnectionManager(webLocalStorage);
+  const result = await autoConnectCore({
+    storage: webLocalStorage,
+    props: {
+      ...props,
+      wallets,
+    },
+    createWalletFn: createWallet,
+    getInstalledWallets: () => {
+      const specifiedWalletIds = new Set(wallets.map((x) => x.id));
+
+      // pass the wallets that are not already specified but are installed by the user
+      const installedWallets = getInstalledWalletProviders()
+        .filter((x) => !specifiedWalletIds.has(x.info.rdns))
+        .map((x) => createWallet(x.info.rdns));
+
+      return installedWallets;
+    },
+    manager,
+  });
+  return result;
+};

package/src/wallets/connection/autoConnectCore.test.ts

@@ -0,0 +1,403 @@
+import { afterEach } from "node:test";
+import { isAddress } from "ethers6";
+import { describe, expect, it, vi } from "vitest";
+import { MockStorage } from "~test/mocks/storage.js";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { TEST_ACCOUNT_A } from "~test/test-wallets.js";
+import { createWalletAdapter } from "../../adapters/wallet-adapter.js";
+import { ethereum } from "../../chains/chain-definitions/ethereum.js";
+import { AUTH_TOKEN_LOCAL_STORAGE_NAME } from "../in-app/core/constants/settings.js";
+import { getUrlToken } from "../in-app/web/lib/get-url-token.js";
+import type { Wallet } from "../interfaces/wallet.js";
+import { createConnectionManager } from "../manager/index.js";
+import type { WalletId } from "../wallet-types.js";
+import { autoConnectCore, handleWalletConnection } from "./autoConnectCore.js";
+
+vi.mock("../in-app/web/lib/get-url-token.ts");
+
+describe("useAutoConnectCore", () => {
+  const mockStorage = new MockStorage();
+  const manager = createConnectionManager(mockStorage);
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should return a useQuery result", async () => {
+    vi.mocked(getUrlToken).mockReturnValue({});
+    const wallet = createWalletAdapter({
+      adaptedAccount: TEST_ACCOUNT_A,
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+
+    expect(
+      await autoConnectCore({
+        storage: mockStorage,
+        props: {
+          wallets: [wallet],
+          client: TEST_CLIENT,
+        },
+        createWalletFn: (id: WalletId) =>
+          createWalletAdapter({
+            adaptedAccount: TEST_ACCOUNT_A,
+            client: TEST_CLIENT,
+            chain: ethereum,
+            onDisconnect: () => {
+              console.warn(id);
+            },
+            switchChain: () => {},
+          }),
+        manager,
+      }),
+    ).toBe(false);
+  });
+
+  it("should return `false` if there's no lastConnectedWalletIds", async () => {
+    vi.mocked(getUrlToken).mockReturnValue({});
+
+    const wallet = createWalletAdapter({
+      adaptedAccount: TEST_ACCOUNT_A,
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+
+    expect(
+      await autoConnectCore({
+        storage: mockStorage,
+        props: {
+          wallets: [wallet],
+          client: TEST_CLIENT,
+        },
+        createWalletFn: (id: WalletId) =>
+          createWalletAdapter({
+            adaptedAccount: TEST_ACCOUNT_A,
+            client: TEST_CLIENT,
+            chain: ethereum,
+            onDisconnect: () => {
+              console.warn(id);
+            },
+            switchChain: () => {},
+          }),
+        manager,
+      }),
+    ).toBe(false);
+  });
+
+  it("should call onTimeout on ... timeout", async () => {
+    vi.mocked(getUrlToken).mockReturnValue({});
+
+    const wallet = createWalletAdapter({
+      adaptedAccount: TEST_ACCOUNT_A,
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+    mockStorage.setItem("thirdweb:active-wallet-id", wallet.id);
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+    // Purposefully mock the wallet.autoConnect method to test the timeout logic
+    wallet.autoConnect = () =>
+      new Promise((resolve) => {
+        setTimeout(() => {
+          // @ts-ignore Mock purpose
+          resolve("Connection successful");
+        }, 2100);
+      });
+
+    await autoConnectCore({
+      storage: mockStorage,
+      props: {
+        wallets: [wallet],
+        client: TEST_CLIENT,
+        onTimeout: () => console.info("TIMEOUTTED"),
+        timeout: 0,
+      },
+      createWalletFn: (id: WalletId) =>
+        createWalletAdapter({
+          adaptedAccount: TEST_ACCOUNT_A,
+          client: TEST_CLIENT,
+          chain: ethereum,
+          onDisconnect: () => {
+            console.warn(id);
+          },
+          switchChain: () => {},
+        }),
+      manager,
+    });
+
+    expect(warnSpy).toHaveBeenCalled();
+    expect(warnSpy).toHaveBeenCalledWith(
+      "AutoConnect timeout: 0ms limit exceeded.",
+    );
+    expect(infoSpy).toHaveBeenCalled();
+    expect(infoSpy).toHaveBeenCalledWith("TIMEOUTTED");
+    warnSpy.mockRestore();
+  });
+
+  it("should handle auth cookie storage correctly", async () => {
+    const mockAuthCookie = "mock-auth-cookie";
+    const wallet = createWalletAdapter({
+      adaptedAccount: TEST_ACCOUNT_A,
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+    vi.mocked(getUrlToken).mockReturnValue({
+      authCookie: mockAuthCookie,
+      walletId: wallet.id,
+    });
+
+    await autoConnectCore({
+      storage: mockStorage,
+      props: {
+        wallets: [wallet],
+        client: TEST_CLIENT,
+      },
+      createWalletFn: () => wallet,
+      manager,
+    });
+
+    const storedCookie = await mockStorage.getItem(
+      AUTH_TOKEN_LOCAL_STORAGE_NAME(TEST_CLIENT.clientId),
+    );
+    expect(storedCookie).toBe(mockAuthCookie);
+  });
+
+  it("should handle error when manager connection fails", async () => {
+    const wallet1 = createWalletAdapter({
+      adaptedAccount: TEST_ACCOUNT_A,
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+
+    mockStorage.setItem("thirdweb:active-wallet-id", wallet1.id);
+    mockStorage.setItem(
+      "thirdweb:connected-wallet-ids",
+      JSON.stringify([wallet1.id]),
+    );
+
+    const addConnectedWalletSpy = vi
+      .spyOn(manager, "connect")
+      .mockRejectedValueOnce(new Error("Connection failed"));
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    await autoConnectCore({
+      storage: mockStorage,
+      props: {
+        wallets: [wallet1],
+        client: TEST_CLIENT,
+      },
+      createWalletFn: () => wallet1,
+      manager,
+    });
+    expect(addConnectedWalletSpy).toHaveBeenCalled();
+
+    expect(warnSpy).toHaveBeenCalled();
+    expect(warnSpy).toHaveBeenCalledWith(
+      "Error auto connecting wallet:",
+      "Connection failed",
+    );
+  });
+
+  it("should connect multiple wallets correctly", async () => {
+    const wallet1 = createWalletAdapter({
+      adaptedAccount: TEST_ACCOUNT_A,
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+
+    const wallet2 = createWalletAdapter({
+      adaptedAccount: { ...TEST_ACCOUNT_A, address: "0x123" },
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+    wallet2.id = "io.metamask" as unknown as "adapter";
+
+    mockStorage.setItem("thirdweb:active-wallet-id", wallet1.id);
+    mockStorage.setItem(
+      "thirdweb:connected-wallet-ids",
+      JSON.stringify([wallet1.id, wallet2.id]),
+    );
+
+    const addConnectedWalletSpy = vi.spyOn(manager, "addConnectedWallet");
+
+    await autoConnectCore({
+      storage: mockStorage,
+      props: {
+        wallets: [wallet1, wallet2],
+        client: TEST_CLIENT,
+      },
+      createWalletFn: () => wallet1,
+      manager,
+    });
+
+    expect(addConnectedWalletSpy).toHaveBeenCalledWith(wallet2);
+  });
+
+  it("should handle onConnect callback correctly", async () => {
+    const mockOnConnect = vi.fn();
+    const wallet = createWalletAdapter({
+      adaptedAccount: TEST_ACCOUNT_A,
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+
+    vi.mocked(getUrlToken).mockReturnValue({});
+    mockStorage.setItem("thirdweb:active-wallet-id", wallet.id);
+    mockStorage.setItem(
+      "thirdweb:connected-wallet-ids",
+      JSON.stringify([wallet.id]),
+    );
+    await autoConnectCore({
+      storage: mockStorage,
+      props: {
+        wallets: [wallet],
+        client: TEST_CLIENT,
+        onConnect: mockOnConnect,
+      },
+      createWalletFn: () => wallet,
+      manager,
+    });
+
+    expect(mockOnConnect).toHaveBeenCalledWith(wallet);
+  });
+  it("should continue even if onConnect callback throws", async () => {
+    const mockOnConnect = vi.fn();
+    mockOnConnect.mockImplementation(() => {
+      throw new Error("onConnect error");
+    });
+    const wallet = createWalletAdapter({
+      adaptedAccount: TEST_ACCOUNT_A,
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+
+    vi.mocked(getUrlToken).mockReturnValue({});
+    mockStorage.setItem("thirdweb:active-wallet-id", wallet.id);
+    mockStorage.setItem(
+      "thirdweb:connected-wallet-ids",
+      JSON.stringify([wallet.id]),
+    );
+    await autoConnectCore({
+      storage: mockStorage,
+      props: {
+        wallets: [wallet],
+        client: TEST_CLIENT,
+        onConnect: mockOnConnect,
+      },
+      createWalletFn: () => wallet,
+      manager,
+    });
+
+    expect(mockOnConnect).toHaveBeenCalledWith(wallet);
+  });
+  it("should call setLastAuthProvider if authProvider is present", async () => {
+    const wallet = createWalletAdapter({
+      adaptedAccount: TEST_ACCOUNT_A,
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+    vi.mocked(getUrlToken).mockReturnValue({
+      authProvider: "email",
+      walletId: wallet.id,
+    });
+    const mockSetLastAuthProvider = vi.fn();
+
+    mockStorage.setItem("thirdweb:active-wallet-id", wallet.id);
+    mockStorage.setItem(
+      "thirdweb:connected-wallet-ids",
+      JSON.stringify([wallet.id]),
+    );
+    await autoConnectCore({
+      storage: mockStorage,
+      props: {
+        wallets: [wallet],
+        client: TEST_CLIENT,
+      },
+      createWalletFn: () => wallet,
+      manager,
+      setLastAuthProvider: mockSetLastAuthProvider,
+    });
+
+    expect(mockSetLastAuthProvider).toHaveBeenCalledWith("email", mockStorage);
+  });
+  it("should set connection status to disconnect if no connectedWallet is returned", async () => {
+    const wallet = createWalletAdapter({
+      adaptedAccount: TEST_ACCOUNT_A,
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+
+    mockStorage.setItem("thirdweb:active-wallet-id", wallet.id);
+    mockStorage.setItem(
+      "thirdweb:connected-wallet-ids",
+      JSON.stringify([wallet.id]),
+    );
+
+    const addConnectedWalletSpy = vi
+      .spyOn(manager, "connect")
+      .mockResolvedValueOnce(null as unknown as Wallet);
+
+    await autoConnectCore({
+      storage: mockStorage,
+      props: {
+        wallets: [wallet],
+        client: TEST_CLIENT,
+      },
+      createWalletFn: () => wallet,
+      manager,
+    });
+
+    expect(addConnectedWalletSpy).toHaveBeenCalled();
+    expect(manager.activeWalletConnectionStatusStore.getValue()).toBe(
+      "disconnected",
+    );
+  });
+});
+
+describe("handleWalletConnection", () => {
+  const wallet = createWalletAdapter({
+    adaptedAccount: TEST_ACCOUNT_A,
+    client: TEST_CLIENT,
+    chain: ethereum,
+    onDisconnect: () => {},
+    switchChain: () => {},
+  });
+  it("should return the correct result", async () => {
+    const result = await handleWalletConnection({
+      client: TEST_CLIENT,
+      lastConnectedChain: ethereum,
+      authResult: undefined,
+      wallet,
+    });
+
+    expect("address" in result).toBe(true);
+    expect(isAddress(result.address)).toBe(true);
+    expect("sendTransaction" in result).toBe(true);
+    expect(typeof result.sendTransaction).toBe("function");
+    expect("signMessage" in result).toBe(true);
+    expect("signTypedData" in result).toBe(true);
+    expect("signTransaction" in result).toBe(true);
+  });
+});