thirdweb 5.75.0 → 5.76.0-nightly-015293eb826b346871696183e96d49da44f31393-20241209000527

package/src/utils/shortenLargeNumber.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { shortenLargeNumber } from "./shortenLargeNumber.js";
+
+describe("shortenLargeNumber", () => {
+  it("should not affect number below 999", () => {
+    expect(shortenLargeNumber(999)).toBe("999");
+  });
+  it("should toLocaleString number below 10000", () => {
+    expect(shortenLargeNumber(1000)).toBe("1,000");
+    expect(shortenLargeNumber(9999)).toBe("9,999");
+  });
+  it("should shorten the number to `k`", () => {
+    expect(shortenLargeNumber(10000)).toBe("10k");
+  });
+  it("should shorten the number to `M`", () => {
+    expect(shortenLargeNumber(1_000_000)).toBe("1M");
+  });
+  it("should shorten the number to `B`", () => {
+    expect(shortenLargeNumber(1_000_000_000)).toBe("1B");
+  });
+  it("should shorten the number to `k`", () => {
+    expect(shortenLargeNumber(11100)).toBe("11.1k");
+  });
+  it("should shorten the number to `M`", () => {
+    expect(shortenLargeNumber(1_100_000)).toBe("1.1M");
+  });
+  it("should shorten the number to `B`", () => {
+    expect(shortenLargeNumber(1_100_000_001)).toBe("1.1B");
+  });
+});

package/src/utils/shortenLargeNumber.ts

@@ -0,0 +1,48 @@
+/**
+ * Shorten the string for large value
+ * Mainly used for
+ * Examples:
+ * 10_000 -> 10k
+ * 1_000_000 -> 1M
+ * 1_000_000_000 -> 1B
+ * @example
+ * ```ts
+ * import { shortenLargeNumber } from "thirdweb/utils";
+ * const numStr = shortenLargeNumber(1_000_000_000, )
+ * ```
+ * @utils
+ */
+export function shortenLargeNumber(value: number) {
+  if (value < 1000) {
+    return value.toString();
+  }
+  if (value < 10_000) {
+    return value.toLocaleString("en-US");
+  }
+  if (value < 1_000_000) {
+    return formatLargeNumber(value, 1_000, "k");
+  }
+  if (value < 1_000_000_000) {
+    return formatLargeNumber(value, 1_000_000, "M");
+  }
+  return formatLargeNumber(value, 1_000_000_000, "B");
+}
+
+/**
+ * Shorten the string for large value (over 4 digits)
+ * 1000 -> 1000
+ * 10_000 -> 10k
+ * 1_000_000 -> 1M
+ * 1_000_000_000 -> 1B
+ */
+function formatLargeNumber(
+  value: number,
+  divisor: number,
+  suffix: "k" | "M" | "B",
+) {
+  const quotient = value / divisor;
+  if (Number.isInteger(quotient)) {
+    return Math.floor(quotient) + suffix;
+  }
+  return quotient.toFixed(1).replace(/\.0$/, "") + suffix;
+}

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.75.0";
+export const version = "5.76.0-nightly-015293eb826b346871696183e96d49da44f31393-20241209000527";

package/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),
@@ -44,7 +47,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("Connection Manager", () => {
     await manager.connect(wallet, { client, onConnect });
 
     expect(onConnect).toHaveBeenCalledWith(wallet);
-    expect(storage.setItem).toHaveBeenCalledWith(expect.any(String), wallet.id);
+    expect(storage.setItem).toHaveBeenCalled();
   });
 
   it("handleConnection should connect smart wallet", async () => {
@@ -65,4 +68,288 @@ describe.runIf(process.env.TW_SECRET_KEY)("Connection Manager", () => {
 
     expect(manager.connectedWallets.getValue()).toContain(wallet);
   });
+
+  it("should disconnect the active wallet when the EOA disconnects", async () => {
+    const manager = createConnectionManager(storage);
+
+    const smartWallet = await manager.handleConnection(wallet, {
+      client,
+      accountAbstraction: smartWalletOptions,
+    });
+
+    expect(manager.activeWalletStore.getValue()).toBe(smartWallet);
+
+    await wallet.disconnect();
+
+    expect(wallet.subscribe).toHaveBeenCalledWith(
+      "disconnect",
+      expect.any(Function),
+    );
+  });
+
+  it("should clear active wallet data on disconnect", async () => {
+    const manager = createConnectionManager(storage);
+
+    await manager.handleConnection(wallet, { client });
+
+    // Simulate wallet disconnect
+    manager.disconnectWallet(wallet);
+
+    expect(storage.removeItem).toHaveBeenCalledWith(
+      "thirdweb:active-wallet-id",
+    );
+    expect(manager.activeAccountStore.getValue()).toBeUndefined();
+    expect(manager.activeWalletChainStore.getValue()).toBeUndefined();
+    expect(manager.activeWalletStore.getValue()).toBeUndefined();
+    expect(manager.activeWalletConnectionStatusStore.getValue()).toBe(
+      "disconnected",
+    );
+  });
+
+  it("should throw an error if wallet has no account", async () => {
+    const manager = createConnectionManager(storage);
+
+    wallet = {
+      id: "wallet-id",
+      getAccount: vi.fn().mockReturnValue(null),
+      subscribe: vi.fn(),
+      disconnect: vi.fn(),
+      switchChain: vi.fn(),
+      getChain: vi.fn().mockReturnValue(sepolia),
+      getConfig: vi.fn(),
+    } as unknown as Wallet;
+
+    await expect(manager.handleConnection(wallet, { client })).rejects.toThrow(
+      "Cannot set a wallet without an account as active",
+    );
+  });
+
+  it("should set active wallet and update storage", async () => {
+    const manager = createConnectionManager(storage);
+
+    await manager.setActiveWallet(wallet);
+
+    expect(manager.activeWalletStore.getValue()).toBe(wallet);
+    expect(storage.setItem).toHaveBeenCalledWith(
+      "thirdweb:active-wallet-id",
+      wallet.id,
+    );
+  });
+
+  it("should switch active wallet chain", async () => {
+    const manager = createConnectionManager(storage);
+
+    await manager.handleConnection(wallet, { client });
+
+    const newChain = {
+      id: 2,
+      name: "New Chain",
+      rpc: "https://rpc.example.com",
+    };
+
+    // Mock the switchChain method to update the activeWalletChainStore
+    wallet.switchChain = vi.fn().mockImplementation((chain) => {
+      manager.activeWalletChainStore.setValue(chain);
+    });
+
+    await manager.switchActiveWalletChain(newChain);
+
+    expect(wallet.switchChain).toHaveBeenCalledWith(newChain);
+  });
+
+  it("should define chains", async () => {
+    const manager = createConnectionManager(storage);
+    await manager.handleConnection(wallet, { client });
+
+    const chains = [
+      { id: 1, name: "Chain 1", rpc: "https://rpc1.example.com" },
+      { id: 2, name: "Chain 2", rpc: "https://rpc2.example.com" },
+    ];
+    manager.defineChains(chains);
+
+    const activeWalletChain = manager.activeWalletChainStore.getValue();
+    expect(activeWalletChain).toBeDefined();
+  });
+
+  it("should remove connected wallet", () => {
+    const manager = createConnectionManager(storage);
+
+    manager.addConnectedWallet(wallet);
+    expect(manager.connectedWallets.getValue()).toContain(wallet);
+
+    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),
+    );
+  });
 });

package/src/wallets/manager/index.ts

@@ -125,27 +125,26 @@ export function createConnectionManager(storage: AsyncStorage) {
   ) => {
     const account = wallet.getAccount();
     if (!account) {
-      throw new Error("Can not set a wallet without an account as active");
+      throw new Error("Cannot set a wallet without an account as active");
     }
 
     const activeWallet = await (async () => {
       if (options?.accountAbstraction && !hasSmartAccount(wallet)) {
         return await handleSmartWalletConnection(
-          account,
+          wallet,
           options.client,
           options.accountAbstraction,
+          onWalletDisconnect,
         );
       } else {
         return wallet;
       }
     })();
 
-    // add personal wallet to connected wallets list
-    addConnectedWallet(wallet);
+    await storage.setItem(LAST_ACTIVE_EOA_ID, wallet.id);
 
-    if (wallet.id !== "smart") {
-      await storage.setItem(LAST_ACTIVE_EOA_ID, wallet.id);
-    }
+    // add personal wallet to connected wallets list even if it's not the active one
+    addConnectedWallet(wallet);
 
     handleSetActiveWallet(activeWallet);
 
@@ -158,22 +157,6 @@ export function createConnectionManager(storage: AsyncStorage) {
     return activeWallet;
   };
 
-  const handleSmartWalletConnection = async (
-    signer: Account,
-    client: ThirdwebClient,
-    options: SmartWalletOptions,
-  ) => {
-    const wallet = smartWallet(options);
-
-    await wallet.connect({
-      personalAccount: signer,
-      client: client,
-      chain: options.chain,
-    });
-
-    return wallet;
-  };
-
   const connect = async (wallet: Wallet, options?: ConnectManagerOptions) => {
     // connectedWallet can be either wallet or smartWallet
     const connectedWallet = await handleConnection(wallet, options);
@@ -184,7 +167,7 @@ export function createConnectionManager(storage: AsyncStorage) {
   const handleSetActiveWallet = (activeWallet: Wallet) => {
     const account = activeWallet.getAccount();
     if (!account) {
-      throw new Error("Can not set a wallet without an account as active");
+      throw new Error("Cannot set a wallet without an account as active");
     }
 
     // also add it to connected wallets if it's not already there
@@ -357,11 +340,9 @@ export async function getStoredActiveWalletId(
     if (value) {
       return value as WalletId;
     }
+  } catch {}
 
-    return null;
-  } catch {
-    return null;
-  }
+  return null;
 }
 
 /**
@@ -375,9 +356,41 @@ export async function getLastConnectedChain(
     if (value) {
       return JSON.parse(value) as Chain;
     }
+  } catch {}
 
-    return null;
-  } catch {
-    return null;
-  }
+  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;
+};

package/src/wallets/wallet-connect/receiver/receiver.test.ts

@@ -27,7 +27,7 @@ const URI_MOCK =
 
 const DEFAULT_METADATA = getDefaultAppMetadata();
 
-const listeners: Record<string, (event?: unknown) => Promise<void>> = {};
+const listeners: Record<string, (_event?: unknown) => Promise<void>> = {};
 
 const signClientMock = {
   on: vi.fn((event, listener) => {

package/src/wallets/wallet-connect/types.ts

@@ -160,7 +160,7 @@ export type WCConnectOptions = {
        * })
        * ```
        */
-      onDisplayUri?: (uri: string) => void;
+      onDisplayUri?: (_uri: string) => void;
     }
   >;
 };

package/src/wallets/wallet-types.ts

@@ -134,7 +134,7 @@ export type WalletAutoConnectionOption<T extends WalletId> =
  * @example
  * ```ts
  * type X = WalletCreationOptions<'io.metamask'>
- * ````
+ * ```
  */
 export type WalletCreationOptions<T extends WalletId> = T extends "smart"
   ? SmartWalletOptions