more tests

Author: gregfromstl

packages/thirdweb/package.json

@@ -273,6 +273,7 @@
     "test:watch": "vitest -c ./test/vitest.config.ts dev",
     "test": "vitest run -c ./test/vitest.config.ts --coverage",
     "test:cov": "vitest dev -c ./test/vitest.config.ts --coverage",
+    "test:ui": "vitest dev -c ./test/vitest.config.ts --coverage --ui",
     "test:dev": "vitest run -c ./test/vitest.config.ts",
     "test:react": "vitest run -c ./test/vitest.config.ts dev --ui src/react",
     "typedoc": "bun run scripts/typedoc.mjs",

packages/thirdweb/src/wallets/manager/connection-manager.test.ts

@@ -6,7 +6,10 @@ import type { ThirdwebClient } from "../../client/client.js";
 import type { AsyncStorage } from "../../utils/storage/AsyncStorage.js";
 import type { Account, Wallet } from "../interfaces/wallet.js";
 import type { SmartWalletOptions } from "../smart/types.js";
-import { createConnectionManager } from "./index.js";
+import {
+  createConnectionManager,
+  handleSmartWalletConnection,
+} from "./index.js";
 
 describe.runIf(process.env.TW_SECRET_KEY)("Connection Manager", () => {
   let storage: AsyncStorage;
@@ -26,7 +29,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("Connection Manager", () => {
     wallet = {
       id: "wallet-id",
       getAccount: vi.fn().mockReturnValue(account),
-      subscribe: vi.fn(),
+      subscribe: vi.fn().mockReturnValue(vi.fn()),
       disconnect: vi.fn(),
       switchChain: vi.fn(),
       getChain: vi.fn().mockReturnValue(sepolia),
@@ -177,4 +180,176 @@ describe.runIf(process.env.TW_SECRET_KEY)("Connection Manager", () => {
     manager.removeConnectedWallet(wallet);
     expect(manager.connectedWallets.getValue()).not.toContain(wallet);
   });
+
+  it("should update active wallet chain to a defined chain", async () => {
+    const manager = createConnectionManager(storage);
+
+    // Connect the wallet to initialize the active wallet chain
+    await manager.handleConnection(wallet, { client });
+
+    // Define a new chain and update the definedChainsStore
+    const newChain = {
+      id: 11155111,
+      name: "New Defined Chain",
+      rpc: "https://rpc3.example.com",
+    };
+    manager.defineChains([newChain]);
+
+    // Simulate the effect that updates the active wallet chain
+    const definedChain = manager.activeWalletChainStore.getValue();
+    expect(definedChain).toEqual(newChain);
+  });
+});
+
+describe("handleSmartWalletConnection", () => {
+  let client: ThirdwebClient;
+  let eoaWallet: Wallet;
+  let smartWalletOptions: SmartWalletOptions;
+
+  beforeEach(() => {
+    client = TEST_CLIENT;
+    eoaWallet = {
+      id: "eoa-wallet-id",
+      getAccount: vi.fn().mockReturnValue(TEST_ACCOUNT_A),
+      subscribe: vi.fn().mockReturnValue(vi.fn()),
+      disconnect: vi.fn(),
+      switchChain: vi.fn(),
+      getChain: vi.fn().mockReturnValue(sepolia),
+      getConfig: vi.fn(),
+    } as unknown as Wallet;
+    smartWalletOptions = {
+      chain: sepolia,
+    } as SmartWalletOptions;
+  });
+
+  it("should connect a smart wallet and subscribe to disconnect event", async () => {
+    const onWalletDisconnect = vi.fn();
+    const smartWallet = await handleSmartWalletConnection(
+      eoaWallet,
+      client,
+      smartWalletOptions,
+      onWalletDisconnect,
+    );
+
+    expect(smartWallet.getAccount()).toBeTruthy();
+
+    expect(eoaWallet.subscribe).toHaveBeenCalledWith(
+      "disconnect",
+      expect.any(Function),
+    );
+  });
+
+  it("should call onWalletDisconnect when EOA wallet disconnects", async () => {
+    const onWalletDisconnect = vi.fn();
+    const smartWallet = await handleSmartWalletConnection(
+      eoaWallet,
+      client,
+      smartWalletOptions,
+      onWalletDisconnect,
+    );
+
+    // biome-ignore lint/suspicious/noExplicitAny: Mocked function
+    const disconnectCallback = (eoaWallet.subscribe as any).mock.calls[0][1];
+    disconnectCallback();
+
+    expect(onWalletDisconnect).toHaveBeenCalledWith(smartWallet);
+  });
+
+  it("should throw an error if EOA wallet has no account", async () => {
+    eoaWallet.getAccount = vi.fn().mockReturnValue(null);
+
+    await expect(
+      handleSmartWalletConnection(
+        eoaWallet,
+        client,
+        smartWalletOptions,
+        vi.fn(),
+      ),
+    ).rejects.toThrow("Cannot set a wallet without an account as active");
+  });
+});
+
+describe("Connection Manager Error Handling", () => {
+  let storage: AsyncStorage;
+  let client: ThirdwebClient;
+  let wallet: Wallet;
+
+  beforeEach(() => {
+    storage = {
+      getItem: vi.fn(),
+      setItem: vi.fn(),
+      removeItem: vi.fn(),
+    };
+    client = TEST_CLIENT;
+    wallet = {
+      id: "wallet-id",
+      getAccount: vi.fn().mockReturnValue(null), // Simulate wallet without an account
+      subscribe: vi.fn(),
+      disconnect: vi.fn(),
+      switchChain: vi.fn(),
+      getChain: vi.fn().mockReturnValue(sepolia),
+      getConfig: vi.fn(),
+    } as unknown as Wallet;
+  });
+
+  it("should throw an error if trying to set a wallet without an account as active", async () => {
+    const manager = createConnectionManager(storage);
+
+    await expect(manager.setActiveWallet(wallet)).rejects.toThrow(
+      "Cannot set a wallet without an account as active",
+    );
+  });
+
+  it("should throw an error if handleConnection is called with a wallet without an account", async () => {
+    const manager = createConnectionManager(storage);
+
+    await expect(manager.handleConnection(wallet, { client })).rejects.toThrow(
+      "Cannot set a wallet without an account as active",
+    );
+  });
+});
+
+describe("Connection Manager Event Subscriptions", () => {
+  let storage: AsyncStorage;
+  let client: ThirdwebClient;
+  let wallet: Wallet;
+  let account: Account;
+
+  beforeEach(() => {
+    storage = {
+      getItem: vi.fn(),
+      setItem: vi.fn(),
+      removeItem: vi.fn(),
+    };
+    client = TEST_CLIENT;
+    account = TEST_ACCOUNT_A;
+    wallet = {
+      id: "wallet-id",
+      getAccount: vi.fn().mockReturnValue(account),
+      subscribe: vi.fn().mockReturnValue(vi.fn()),
+      disconnect: vi.fn(),
+      switchChain: vi.fn(),
+      getChain: vi.fn().mockReturnValue(sepolia),
+      getConfig: vi.fn(),
+    } as unknown as Wallet;
+  });
+
+  it("should subscribe to accountChanged, chainChanged, and disconnect events", async () => {
+    const manager = createConnectionManager(storage);
+
+    await manager.handleConnection(wallet, { client });
+
+    expect(wallet.subscribe).toHaveBeenCalledWith(
+      "accountChanged",
+      expect.any(Function),
+    );
+    expect(wallet.subscribe).toHaveBeenCalledWith(
+      "chainChanged",
+      expect.any(Function),
+    );
+    expect(wallet.subscribe).toHaveBeenCalledWith(
+      "disconnect",
+      expect.any(Function),
+    );
+  });
 });

packages/thirdweb/src/wallets/manager/index.ts

@@ -134,6 +134,7 @@ export function createConnectionManager(storage: AsyncStorage) {
           wallet,
           options.client,
           options.accountAbstraction,
+          onWalletDisconnect,
         );
       } else {
         return wallet;
@@ -156,36 +157,6 @@ export function createConnectionManager(storage: AsyncStorage) {
     return activeWallet;
   };
 
-  const handleSmartWalletConnection = async (
-    eoaWallet: Wallet,
-    client: ThirdwebClient,
-    options: SmartWalletOptions,
-  ) => {
-    const signer = eoaWallet.getAccount();
-    if (!signer) {
-      throw new Error("Cannot set a wallet without an account as active");
-    }
-
-    const wallet = smartWallet(options);
-
-    await wallet.connect({
-      personalAccount: signer,
-      client: client,
-      chain: options.chain,
-    });
-
-    // Disconnect the active wallet when the EOA disconnects if it the active wallet is a smart wallet
-    const disconnectUnsub = eoaWallet.subscribe("disconnect", () => {
-      handleDisconnect();
-    });
-    const handleDisconnect = () => {
-      disconnectUnsub();
-      onWalletDisconnect(wallet);
-    };
-
-    return wallet;
-  };
-
   const connect = async (wallet: Wallet, options?: ConnectManagerOptions) => {
     // connectedWallet can be either wallet or smartWallet
     const connectedWallet = await handleConnection(wallet, options);
@@ -227,6 +198,7 @@ export function createConnectionManager(storage: AsyncStorage) {
     });
 
     const handleDisconnect = () => {
+      console.log("disconnecting");
       onWalletDisconnect(activeWallet);
       unsubAccounts();
       unsubChainChanged();
@@ -389,3 +361,37 @@ export async function getLastConnectedChain(
 
   return null;
 }
+
+/**
+ * @internal
+ */
+export const handleSmartWalletConnection = async (
+  eoaWallet: Wallet,
+  client: ThirdwebClient,
+  options: SmartWalletOptions,
+  onWalletDisconnect: (wallet: Wallet) => void,
+) => {
+  const signer = eoaWallet.getAccount();
+  if (!signer) {
+    throw new Error("Cannot set a wallet without an account as active");
+  }
+
+  const wallet = smartWallet(options);
+
+  await wallet.connect({
+    personalAccount: signer,
+    client: client,
+    chain: options.chain,
+  });
+
+  // Disconnect the active wallet when the EOA disconnects if it the active wallet is a smart wallet
+  const disconnectUnsub = eoaWallet.subscribe("disconnect", () => {
+    handleDisconnect();
+  });
+  const handleDisconnect = () => {
+    disconnectUnsub();
+    onWalletDisconnect(wallet);
+  };
+
+  return wallet;
+};