thirdweb 5.80.1-nightly-a3f59e50e249d8b4fac765e025fc2cd102093e9c-20250105000328 → 5.81.0

package/src/react/core/hooks/connection/types.ts

@@ -113,4 +113,9 @@ export type AutoConnectProps = {
    * Optional chain to autoconnect to
    */
   chain?: Chain;
+
+  /**
+   * Callback to be called when the connection is timeout-ed
+   */
+  onTimeout?: () => void;
 };

package/src/react/core/hooks/wallets/useAutoConnect.ts

@@ -1,9 +1,12 @@
 "use client";
 
 import { useQuery } from "@tanstack/react-query";
+import type { Chain } from "../../../../chains/types.js";
+import type { ThirdwebClient } from "../../../../client/client.js";
 import type { AsyncStorage } from "../../../../utils/storage/AsyncStorage.js";
 import { isEcosystemWallet } from "../../../../wallets/ecosystem/is-ecosystem-wallet.js";
 import { ClientScopedStorage } from "../../../../wallets/in-app/core/authentication/client-scoped-storage.js";
+import type { AuthStoredTokenWithCookieReturnType } from "../../../../wallets/in-app/core/authentication/types.js";
 import { getUrlToken } from "../../../../wallets/in-app/web/lib/get-url-token.js";
 import type { Wallet } from "../../../../wallets/interfaces/wallet.js";
 import {
@@ -83,14 +86,6 @@ export function useAutoConnectCore(
     const lastConnectedChain =
       (await getLastConnectedChain(storage)) || props.chain;
 
-    async function handleWalletConnection(wallet: Wallet) {
-      return wallet.autoConnect({
-        client: props.client,
-        chain: lastConnectedChain ?? undefined,
-        authResult,
-      });
-    }
-
     const availableWallets = [...wallets, ...(getInstalledWallets?.() ?? [])];
     const activeWallet =
       lastActiveWalletId &&
@@ -100,9 +95,22 @@ export function useAutoConnectCore(
     if (activeWallet) {
       try {
         setConnectionStatus("connecting"); // only set connecting status if we are connecting the last active EOA
-        await timeoutPromise(handleWalletConnection(activeWallet), {
-          ms: timeout,
-          message: `AutoConnect timeout: ${timeout}ms limit exceeded.`,
+        await timeoutPromise(
+          handleWalletConnection({
+            wallet: activeWallet,
+            client: props.client,
+            lastConnectedChain,
+            authResult,
+          }),
+          {
+            ms: timeout,
+            message: `AutoConnect timeout: ${timeout}ms limit exceeded.`,
+          },
+        ).catch((err) => {
+          console.warn(err.message);
+          if (props.onTimeout) {
+            props.onTimeout();
+          }
         });
 
         // connected wallet could be activeWallet or smart wallet
@@ -138,7 +146,12 @@ export function useAutoConnectCore(
 
     for (const wallet of otherWallets) {
       try {
-        await handleWalletConnection(wallet);
+        await handleWalletConnection({
+          wallet,
+          client: props.client,
+          lastConnectedChain,
+          authResult,
+        });
         manager.addConnectedWallet(wallet);
       } catch {
         // no-op
@@ -158,3 +171,19 @@ export function useAutoConnectCore(
 
   return query;
 }
+
+/**
+ * @internal
+ */
+export async function handleWalletConnection(props: {
+  wallet: Wallet;
+  client: ThirdwebClient;
+  authResult: AuthStoredTokenWithCookieReturnType | undefined;
+  lastConnectedChain: Chain | undefined;
+}) {
+  return props.wallet.autoConnect({
+    client: props.client,
+    chain: props.lastConnectedChain,
+    authResult: props.authResult,
+  });
+}

package/src/react/core/hooks/wallets/useAutoConnectCore.test.tsx

@@ -0,0 +1,187 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+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 { isAddress } from "../../../../utils/address.js";
+import { createConnectionManager } from "../../../../wallets/manager/index.js";
+import type { WalletId } from "../../../../wallets/wallet-types.js";
+import { ThirdwebProvider } from "../../../web/providers/thirdweb-provider.js";
+import { ConnectionManagerCtx } from "../../providers/connection-manager.js";
+import {
+  handleWalletConnection,
+  useAutoConnectCore,
+} from "./useAutoConnect.js";
+
+describe("useAutoConnectCore", () => {
+  const mockStorage = new MockStorage();
+  const manager = createConnectionManager(mockStorage);
+
+  // Create a wrapper component with the mocked context
+  const wrapper = ({ children }: { children: ReactNode }) => {
+    return (
+      <ThirdwebProvider>
+        <ConnectionManagerCtx.Provider value={manager}>
+          {children}
+        </ConnectionManagerCtx.Provider>
+      </ThirdwebProvider>
+    );
+  };
+
+  it("should return a useQuery result", async () => {
+    const wallet = createWalletAdapter({
+      adaptedAccount: TEST_ACCOUNT_A,
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+    const { result } = renderHook(
+      () =>
+        useAutoConnectCore(
+          mockStorage,
+          {
+            wallets: [wallet],
+            client: TEST_CLIENT,
+          },
+          (id: WalletId) =>
+            createWalletAdapter({
+              adaptedAccount: TEST_ACCOUNT_A,
+              client: TEST_CLIENT,
+              chain: ethereum,
+              onDisconnect: () => {
+                console.warn(id);
+              },
+              switchChain: () => {},
+            }),
+        ),
+      { wrapper },
+    );
+    expect("data" in result.current).toBeTruthy();
+    await waitFor(() => {
+      expect(typeof result.current.data).toBe("boolean");
+    });
+  });
+
+  it("should return `false` if there's no lastConnectedWalletIds", async () => {
+    const wallet = createWalletAdapter({
+      adaptedAccount: TEST_ACCOUNT_A,
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+    const { result } = renderHook(
+      () =>
+        useAutoConnectCore(
+          mockStorage,
+          {
+            wallets: [wallet],
+            client: TEST_CLIENT,
+          },
+          (id: WalletId) =>
+            createWalletAdapter({
+              adaptedAccount: TEST_ACCOUNT_A,
+              client: TEST_CLIENT,
+              chain: ethereum,
+              onDisconnect: () => {
+                console.warn(id);
+              },
+              switchChain: () => {},
+            }),
+        ),
+      { wrapper },
+    );
+    await waitFor(
+      () => {
+        expect(result.current.data).toBe(false);
+      },
+      { timeout: 1000 },
+    );
+  });
+
+  it("should call onTimeout on ... timeout", async () => {
+    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);
+      });
+    renderHook(
+      () =>
+        useAutoConnectCore(
+          mockStorage,
+          {
+            wallets: [wallet],
+            client: TEST_CLIENT,
+            onTimeout: () => console.info("TIMEOUTTED"),
+            timeout: 0,
+          },
+          (id: WalletId) =>
+            createWalletAdapter({
+              adaptedAccount: TEST_ACCOUNT_A,
+              client: TEST_CLIENT,
+              chain: ethereum,
+              onDisconnect: () => {
+                console.warn(id);
+              },
+              switchChain: () => {},
+            }),
+        ),
+      { wrapper },
+    );
+    await waitFor(
+      () => {
+        expect(warnSpy).toHaveBeenCalled();
+        expect(warnSpy).toHaveBeenCalledWith(
+          "AutoConnect timeout: 0ms limit exceeded.",
+        );
+        expect(infoSpy).toHaveBeenCalled();
+        expect(infoSpy).toHaveBeenCalledWith("TIMEOUTTED");
+        warnSpy.mockRestore();
+      },
+      { timeout: 2000 },
+    );
+  });
+});
+
+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);
+  });
+});

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.80.1-nightly-a3f59e50e249d8b4fac765e025fc2cd102093e9c-20250105000328";
+export const version = "5.81.0";

package/src/wallets/in-app/core/wallet/in-app-core.test.ts

@@ -1,42 +1,54 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { TEST_CLIENT } from "../../../../../test/src/test-clients.js";
+import { TEST_ACCOUNT_A } from "../../../../../test/src/test-wallets.js";
 import { baseSepolia } from "../../../../chains/chain-definitions/base-sepolia.js";
-import { createThirdwebClient } from "../../../../client/client.js";
 import { getEcosystemInfo } from "../../../ecosystem/get-ecosystem-wallet-auth-options.js";
-import type { Account } from "../../../interfaces/wallet.js";
+import { predictSmartAccountAddress } from "../../../smart/lib/calls.js";
+import { DEFAULT_ACCOUNT_FACTORY_V0_6 } from "../../../smart/lib/constants.js";
+import type { AuthLoginReturnType } from "../authentication/types.js";
 import type { InAppConnector } from "../interfaces/connector.js";
 import { createInAppWallet } from "./in-app-core.js";
-import { autoConnectInAppWallet, connectInAppWallet } from "./index.js";
+import * as InAppWallet from "./index.js";
 
 vi.mock("../../../../analytics/track/connect.js", () => ({
   trackConnect: vi.fn(),
 }));
 
-vi.mock("./index.js", () => ({
-  autoConnectInAppWallet: vi.fn(),
-  connectInAppWallet: vi.fn(),
-}));
-
+vi.spyOn(InAppWallet, "connectInAppWallet");
+vi.spyOn(InAppWallet, "autoConnectInAppWallet");
 vi.mock("../../../ecosystem/get-ecosystem-wallet-auth-options.js", () => ({
   getEcosystemInfo: vi.fn(),
 }));
 
-describe("createInAppWallet", () => {
-  const mockClient = createThirdwebClient({
-    clientId: "test-client",
-  });
+describe.runIf(process.env.TW_SECRET_KEY)("createInAppWallet", () => {
+  const mockClient = TEST_CLIENT;
   const mockChain = baseSepolia;
-  const mockAccount = { address: "0x123" } as Account;
+  const mockAccount = TEST_ACCOUNT_A;
+  const mockUser = {
+    status: "Logged In, Wallet Initialized",
+    walletAddress: TEST_ACCOUNT_A.address,
+    authDetails: {
+      userWalletId: TEST_ACCOUNT_A.address,
+      recoveryShareManagement: "ENCLAVE",
+      email: "test@test.com",
+    },
+    account: mockAccount,
+  } as const;
+  const mockAuthResult: AuthLoginReturnType = {
+    user: mockUser,
+  };
 
   const mockConnectorFactory = vi.fn(() =>
     Promise.resolve({
-      connect: vi.fn(),
+      connect: vi.fn().mockResolvedValue(mockAuthResult),
       logout: vi.fn(() => Promise.resolve({ success: true })),
       authenticate: vi.fn(),
       getAccounts: vi.fn(),
       getAccount: vi.fn(),
       getProfiles: vi.fn(),
-      getUser: vi.fn(),
+      getUser: vi.fn().mockResolvedValue(mockUser),
       linkProfile: vi.fn(),
+      unlinkProfile: vi.fn(),
       preAuthenticate: vi.fn(),
     } as InAppConnector),
   );
@@ -46,8 +58,6 @@ describe("createInAppWallet", () => {
   });
 
   it("should connect successfully", async () => {
-    vi.mocked(connectInAppWallet).mockResolvedValue([mockAccount, mockChain]);
-
     const wallet = createInAppWallet({
       connectorFactory: mockConnectorFactory,
     });
@@ -61,7 +71,7 @@ describe("createInAppWallet", () => {
     });
 
     expect(result).toBe(mockAccount);
-    expect(connectInAppWallet).toHaveBeenCalledWith(
+    expect(InAppWallet.connectInAppWallet).toHaveBeenCalledWith(
       expect.objectContaining({
         client: mockClient,
         chain: mockChain,
@@ -72,11 +82,6 @@ describe("createInAppWallet", () => {
   });
 
   it("should auto connect successfully", async () => {
-    vi.mocked(autoConnectInAppWallet).mockResolvedValue([
-      mockAccount,
-      mockChain,
-    ]);
-
     const wallet = createInAppWallet({
       connectorFactory: mockConnectorFactory,
     });
@@ -87,7 +92,7 @@ describe("createInAppWallet", () => {
     });
 
     expect(result).toBe(mockAccount);
-    expect(autoConnectInAppWallet).toHaveBeenCalledWith(
+    expect(InAppWallet.autoConnectInAppWallet).toHaveBeenCalledWith(
       expect.objectContaining({
         client: mockClient,
         chain: mockChain,
@@ -102,15 +107,13 @@ describe("createInAppWallet", () => {
       smartAccountOptions: {
         defaultChainId: mockChain.id,
         sponsorGas: true,
-        accountFactoryAddress: "0x456",
+        accountFactoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_6,
       },
       authOptions: [],
       name: "hello world",
       slug: "test-ecosystem",
     });
 
-    vi.mocked(connectInAppWallet).mockResolvedValue([mockAccount, mockChain]);
-
     const wallet = createInAppWallet({
       connectorFactory: mockConnectorFactory,
       ecosystem: { id: "ecosystem.test-ecosystem" },
@@ -124,8 +127,14 @@ describe("createInAppWallet", () => {
       verificationCode: "",
     });
 
-    expect(result).toBe(mockAccount);
-    expect(connectInAppWallet).toHaveBeenCalledWith(
+    const expectedSmartAccountAddress = await predictSmartAccountAddress({
+      factoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_6,
+      chain: mockChain,
+      adminAddress: TEST_ACCOUNT_A.address,
+      client: mockClient,
+    });
+    expect(result.address).toBe(expectedSmartAccountAddress);
+    expect(InAppWallet.connectInAppWallet).toHaveBeenCalledWith(
       expect.objectContaining({
         client: mockClient,
         chain: mockChain,
@@ -134,7 +143,7 @@ describe("createInAppWallet", () => {
         smartAccount: expect.objectContaining({
           chain: mockChain,
           sponsorGas: true,
-          factoryAddress: "0x456",
+          factoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_6,
         }),
       }),
       expect.any(Object),
@@ -145,15 +154,13 @@ describe("createInAppWallet", () => {
       smartAccountOptions: {
         defaultChainId: mockChain.id,
         sponsorGas: true,
-        accountFactoryAddress: "0x456",
+        accountFactoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_6,
       },
       authOptions: [],
       name: "hello world",
       slug: "test-ecosystem",
     });
 
-    vi.mocked(connectInAppWallet).mockResolvedValue([mockAccount, mockChain]);
-
     const wallet = createInAppWallet({
       connectorFactory: mockConnectorFactory,
       ecosystem: { id: "ecosystem.test-ecosystem" },
@@ -166,8 +173,14 @@ describe("createInAppWallet", () => {
       verificationCode: "",
     });
 
-    expect(result).toBe(mockAccount);
-    expect(connectInAppWallet).toHaveBeenCalledWith(
+    const expectedSmartAccountAddress = await predictSmartAccountAddress({
+      factoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_6,
+      chain: mockChain,
+      adminAddress: TEST_ACCOUNT_A.address,
+      client: mockClient,
+    });
+    expect(result.address).toBe(expectedSmartAccountAddress);
+    expect(InAppWallet.connectInAppWallet).toHaveBeenCalledWith(
       expect.objectContaining({
         client: mockClient,
       }),
@@ -175,7 +188,7 @@ describe("createInAppWallet", () => {
         smartAccount: expect.objectContaining({
           chain: mockChain,
           sponsorGas: true,
-          factoryAddress: "0x456",
+          factoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_6,
         }),
       }),
       expect.any(Object),
@@ -187,18 +200,13 @@ describe("createInAppWallet", () => {
       smartAccountOptions: {
         defaultChainId: mockChain.id,
         sponsorGas: true,
-        accountFactoryAddress: "0x456",
+        accountFactoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_6,
       },
       authOptions: [],
       name: "hello world",
       slug: "test-ecosystem",
     });
 
-    vi.mocked(autoConnectInAppWallet).mockResolvedValue([
-      mockAccount,
-      mockChain,
-    ]);
-
     const wallet = createInAppWallet({
       connectorFactory: mockConnectorFactory,
       ecosystem: { id: "ecosystem.test-ecosystem" },
@@ -209,8 +217,14 @@ describe("createInAppWallet", () => {
       chain: mockChain,
     });
 
-    expect(result).toBe(mockAccount);
-    expect(autoConnectInAppWallet).toHaveBeenCalledWith(
+    const expectedSmartAccountAddress = await predictSmartAccountAddress({
+      factoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_6,
+      chain: mockChain,
+      adminAddress: TEST_ACCOUNT_A.address,
+      client: mockClient,
+    });
+    expect(result.address).toBe(expectedSmartAccountAddress);
+    expect(InAppWallet.autoConnectInAppWallet).toHaveBeenCalledWith(
       expect.objectContaining({
         client: mockClient,
         chain: mockChain,
@@ -219,7 +233,7 @@ describe("createInAppWallet", () => {
         smartAccount: expect.objectContaining({
           chain: mockChain,
           sponsorGas: true,
-          factoryAddress: "0x456",
+          factoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_6,
         }),
       }),
       expect.any(Object),
@@ -231,18 +245,13 @@ describe("createInAppWallet", () => {
       smartAccountOptions: {
         defaultChainId: mockChain.id,
         sponsorGas: true,
-        accountFactoryAddress: "0x456",
+        accountFactoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_6,
       },
       authOptions: [],
       name: "hello world",
       slug: "test-ecosystem",
     });
 
-    vi.mocked(autoConnectInAppWallet).mockResolvedValue([
-      mockAccount,
-      mockChain,
-    ]);
-
     const wallet = createInAppWallet({
       connectorFactory: mockConnectorFactory,
       ecosystem: { id: "ecosystem.test-ecosystem" },
@@ -252,8 +261,14 @@ describe("createInAppWallet", () => {
       client: mockClient,
     });
 
-    expect(result).toBe(mockAccount);
-    expect(autoConnectInAppWallet).toHaveBeenCalledWith(
+    const expectedSmartAccountAddress = await predictSmartAccountAddress({
+      factoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_6,
+      chain: mockChain,
+      adminAddress: TEST_ACCOUNT_A.address,
+      client: mockClient,
+    });
+    expect(result.address).toBe(expectedSmartAccountAddress);
+    expect(InAppWallet.autoConnectInAppWallet).toHaveBeenCalledWith(
       expect.objectContaining({
         client: mockClient,
       }),
@@ -261,10 +276,56 @@ describe("createInAppWallet", () => {
         smartAccount: expect.objectContaining({
           chain: mockChain,
           sponsorGas: true,
-          factoryAddress: "0x456",
+          factoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_6,
         }),
       }),
       expect.any(Object),
     );
   });
+
+  it("should return undefined for getAdminAccount if the account is not a smart account", () => {
+    const wallet = createInAppWallet({
+      connectorFactory: mockConnectorFactory,
+    });
+
+    expect(wallet.getAdminAccount?.()).toBeUndefined();
+  });
+
+  it("should return undefined if no account is connected", () => {
+    const wallet = createInAppWallet({
+      connectorFactory: mockConnectorFactory,
+    });
+
+    expect(wallet.getAdminAccount?.()).toBeUndefined();
+  });
+
+  it("should return the admin account for a smart account", async () => {
+    vi.unmock("./index.js");
+    vi.mocked(getEcosystemInfo).mockResolvedValue({
+      smartAccountOptions: {
+        defaultChainId: mockChain.id,
+        sponsorGas: true,
+        accountFactoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_6,
+      },
+      authOptions: [],
+      name: "hello world",
+      slug: "test-ecosystem",
+    });
+
+    const wallet = createInAppWallet({
+      connectorFactory: mockConnectorFactory,
+      ecosystem: { id: "ecosystem.test-ecosystem" },
+    });
+
+    const smartAccount = await wallet.connect({
+      client: mockClient,
+      strategy: "email",
+      email: "",
+      verificationCode: "",
+    });
+
+    const adminAccount = wallet.getAdminAccount?.();
+    expect(adminAccount).toBeDefined();
+    expect(adminAccount?.address).not.toBe(smartAccount.address);
+  });
 });