test: Add test suite for fromProvider in EIP-1193 adapter

Author: gregfromstl

packages/thirdweb/src/adapters/eip1193/from-eip1193.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, test, vi } from "vitest";
+import { TEST_ACCOUNT_A } from "~test/test-wallets.js";
+import { ANVIL_CHAIN } from "../../../test/src/chains.js";
+import { TEST_CLIENT } from "../../../test/src/test-clients.js";
+import { trackConnect } from "../../analytics/track/connect.js";
+import { fromProvider } from "./from-eip1193.js";
+import type { EIP1193Provider } from "./types.js";
+
+vi.mock("../../analytics/track/connect.js");
+
+describe("fromProvider", () => {
+  const mockProvider: EIP1193Provider = {
+    on: vi.fn(),
+    removeListener: vi.fn(),
+    request: vi.fn(),
+  };
+
+  const mockAccount = TEST_ACCOUNT_A;
+
+  test("should create a wallet with the correct properties", () => {
+    const wallet = fromProvider({
+      provider: mockProvider,
+      walletId: "io.metamask",
+    });
+
+    expect(wallet.id).toBe("io.metamask");
+    expect(wallet.subscribe).toBeDefined();
+    expect(wallet.connect).toBeDefined();
+    expect(wallet.disconnect).toBeDefined();
+    expect(wallet.getAccount).toBeDefined();
+    expect(wallet.getChain).toBeDefined();
+    expect(wallet.getConfig).toBeDefined();
+    expect(wallet.switchChain).toBeDefined();
+  });
+
+  test("should use 'adapter' as default walletId", () => {
+    const wallet = fromProvider({
+      provider: mockProvider,
+    });
+
+    expect(wallet.id).toBe("adapter");
+  });
+
+  test("should handle async provider function", async () => {
+    const wallet = fromProvider({
+      provider: async () =>
+        Promise.resolve({
+          ...mockProvider,
+          request: () => Promise.resolve([mockAccount.address]),
+        }),
+    });
+
+    // Connect to trigger provider initialization
+    await wallet.connect({
+      client: TEST_CLIENT,
+    });
+
+    expect(wallet.getAccount()?.address).toBe(mockAccount.address);
+  });
+
+  test("should emit events on connect", async () => {
+    const wallet = fromProvider({
+      provider: {
+        ...mockProvider,
+        request: () => Promise.resolve([mockAccount.address]),
+      },
+    });
+
+    const onConnectSpy = vi.fn();
+    wallet.subscribe("onConnect", onConnectSpy);
+
+    await wallet.connect({
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+    });
+
+    expect(onConnectSpy).toHaveBeenCalled();
+    expect(trackConnect).toHaveBeenCalledWith({
+      client: TEST_CLIENT,
+      walletType: "adapter",
+      walletAddress: mockAccount.address,
+    });
+  });
+
+  test("should emit events on disconnect", async () => {
+    const wallet = fromProvider({
+      provider: mockProvider,
+    });
+
+    const onDisconnectSpy = vi.fn();
+    wallet.subscribe("disconnect", onDisconnectSpy);
+
+    await wallet.disconnect();
+
+    expect(onDisconnectSpy).toHaveBeenCalled();
+  });
+
+  test("should handle chain changes", async () => {
+    const wallet = fromProvider({
+      provider: {
+        ...mockProvider,
+        request: () => Promise.resolve([mockAccount.address]),
+      },
+    });
+
+    const onChainChangedSpy = vi.fn();
+    wallet.subscribe("chainChanged", onChainChangedSpy);
+
+    await wallet.connect({
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+    });
+
+    const chain = wallet.getChain();
+    expect(chain).toBe(ANVIL_CHAIN);
+  });
+
+  test("should reset state on disconnect", async () => {
+    const wallet = fromProvider({
+      provider: {
+        ...mockProvider,
+        request: () => Promise.resolve([mockAccount.address]),
+      },
+    });
+
+    mockProvider.request = vi.fn().mockResolvedValueOnce([mockAccount.address]);
+
+    await wallet.connect({
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+    });
+
+    await wallet.disconnect();
+
+    expect(wallet.getAccount()).toBeUndefined();
+    expect(wallet.getChain()).toBeUndefined();
+  });
+});

packages/thirdweb/src/adapters/eip1193/from-eip1193.ts

@@ -1,3 +1,4 @@
+import * as ox__Hex from "ox/Hex";
 import { trackConnect } from "../../analytics/track/connect.js";
 import type { Chain } from "../../chains/types.js";
 import { getCachedChainIfExists } from "../../chains/utils.js";
@@ -9,7 +10,6 @@ import type { Account, Wallet } from "../../wallets/interfaces/wallet.js";
 import { createWalletEmitter } from "../../wallets/wallet-emitter.js";
 import type { WalletId } from "../../wallets/wallet-types.js";
 import type { EIP1193Provider } from "./types.js";
-import * as ox__Hex from "ox/Hex";
 
 export type FromEip1193AdapterOptions = {
   provider: EIP1193Provider | (() => Promise<EIP1193Provider>);
@@ -55,7 +55,7 @@ export function fromProvider(options: FromEip1193AdapterOptions): Wallet {
     chain = undefined;
   }
 
-  let handleDisconnect = async () => { };
+  let handleDisconnect = async () => {};
 
   const unsubscribeDisconnect = emitter.subscribe("disconnect", () => {
     reset();
@@ -75,7 +75,7 @@ export function fromProvider(options: FromEip1193AdapterOptions): Wallet {
   };
 
   return {
-    id: options.walletId as WalletId,
+    id,
     subscribe: emitter.subscribe,
     getConfig: () => undefined,
     getChain() {

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

@@ -70,7 +70,7 @@ export async function connectEip1193Wallet({
 
   const addr = addresses?.[0];
   if (!addr) {
-    throw new Error("no accounts available");
+    throw new Error("Failed to connect to wallet, no accounts available");
   }
 
   // use the first account
@@ -123,7 +123,7 @@ export async function autoConnectEip1193Wallet({
 
   const addr = addresses[0];
   if (!addr) {
-    throw new Error("no accounts available");
+    throw new Error("Failed to connect to wallet, no accounts available");
   }
 
   // use the first account