@tomo-inc/wallet-adaptor-base 0.0.19 → 0.0.21

package/src/__tests__/WalletConnectProvider.test.ts

@@ -0,0 +1,535 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { WalletConnectProvider } from "../wallets/providers/WalletConnectProvider";
+import { WalletConnectClient } from "@tomo-inc/wallet-connect-protocol";
+
+// Mock WalletConnectClient - use vi.hoisted to create mock instance and constructor
+const { mockClient, MockWalletConnectClient } = vi.hoisted(() => {
+  const createMockClient = () => ({
+    initialize: vi.fn().mockResolvedValue(undefined),
+    connect: vi.fn().mockResolvedValue("wc:test-uri"),
+    disconnectSession: vi.fn().mockResolvedValue(undefined),
+    getActiveSessions: vi.fn().mockReturnValue([]),
+    sendRequest: vi.fn().mockResolvedValue("result"),
+    on: vi.fn(),
+    off: vi.fn(),
+  });
+
+  const mockClientInstance = createMockClient();
+
+  // Create a proper constructor function
+  function MockWalletConnectClientConstructor() {
+    return mockClientInstance;
+  }
+
+  // Wrap with vi.fn() to make it spyable
+  const MockClient = vi.fn(MockWalletConnectClientConstructor);
+
+  return {
+    mockClient: mockClientInstance,
+    MockWalletConnectClient: MockClient,
+  };
+});
+
+vi.mock("@tomo-inc/wallet-connect-protocol", () => ({
+  WalletConnectClient: MockWalletConnectClient,
+}));
+
+describe("WalletConnectProvider", () => {
+  let provider: WalletConnectProvider;
+  const config = {
+    projectId: "test-project-id",
+    metadata: {
+      name: "Test App",
+      description: "Test Description",
+      url: "https://test.com",
+      icons: ["https://test.com/icon.png"],
+    },
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    provider = new WalletConnectProvider(config);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("constructor and client listeners", () => {
+    it("should create provider with default namespaces", () => {
+      expect(WalletConnectClient).toHaveBeenCalledWith({
+        projectId: config.projectId,
+        metadata: config.metadata,
+      });
+      expect(mockClient.on).toHaveBeenCalledWith("session_proposal", expect.any(Function));
+      expect(mockClient.on).toHaveBeenCalledWith("session_delete", expect.any(Function));
+      expect(mockClient.on).toHaveBeenCalledWith("session_update", expect.any(Function));
+      expect(mockClient.on).toHaveBeenCalledWith("display_uri", expect.any(Function));
+    });
+
+    it("should handle session_proposal and update session when getActiveSessions returns sessions", () => {
+      const mockSession = {
+        topic: "proposal-topic",
+        namespaces: {
+          eip155: { accounts: ["eip155:1:0xabc"] },
+        },
+      };
+      mockClient.getActiveSessions.mockReturnValue([mockSession]);
+      const sessionProposalHandler = (mockClient.on as any).mock.calls.find((c: any[]) => c[0] === "session_proposal")?.[1];
+      expect(sessionProposalHandler).toBeDefined();
+      const emitSpy = vi.spyOn(provider as any, "emit");
+      sessionProposalHandler();
+      expect(provider["session"]).toEqual(mockSession);
+      expect(provider["accounts"]).toEqual(["0xabc"]);
+      expect(provider["chainId"]).toBe("0x1");
+      expect(emitSpy).toHaveBeenCalledWith("connect", expect.any(Object));
+    });
+
+    it("should handle session_delete and clear session", () => {
+      provider["session"] = { topic: "t", namespaces: {} } as any;
+      provider["accounts"] = ["0x123"];
+      const sessionDeleteHandler = (mockClient.on as any).mock.calls.find((c: any[]) => c[0] === "session_delete")?.[1];
+      sessionDeleteHandler();
+      expect(provider["session"]).toBeNull();
+      expect(provider["accounts"]).toEqual([]);
+    });
+
+    it("should handle session_update and emit accountsChanged", () => {
+      provider["session"] = {
+        topic: "t",
+        namespaces: { eip155: { accounts: ["eip155:1:0xdef"] } },
+      } as any;
+      const sessionUpdateHandler = (mockClient.on as any).mock.calls.find((c: any[]) => c[0] === "session_update")?.[1];
+      provider["updateAccountsFromSession"] = vi.fn();
+      const emitSpy = vi.spyOn(provider as any, "emit");
+      sessionUpdateHandler();
+      expect(provider["updateAccountsFromSession"]).toHaveBeenCalled();
+      expect(emitSpy).toHaveBeenCalledWith("accountsChanged", expect.any(Array));
+    });
+
+    it("should handle display_uri and set uri", () => {
+      const displayUriHandler = (mockClient.on as any).mock.calls.find((c: any[]) => c[0] === "display_uri")?.[1];
+      displayUriHandler({ uri: "wc://new-uri" });
+      expect(provider.uri).toBe("wc://new-uri");
+    });
+
+    it("should use custom namespaces when provided", () => {
+      const customNamespaces = {
+        eip155: {
+          chains: ["eip155:5"],
+          methods: ["eth_chainId"],
+          events: [],
+        },
+      };
+
+      const customProvider = new WalletConnectProvider({
+        ...config,
+        namespaces: customNamespaces,
+      });
+
+      expect(customProvider).toBeDefined();
+    });
+  });
+
+  describe("initialize", () => {
+    it("should initialize client and get URI when no active sessions", async () => {
+      mockClient.getActiveSessions.mockReturnValue([]);
+      mockClient.connect.mockResolvedValue("wc:new-uri");
+
+      await provider.initialize();
+
+      expect(mockClient.initialize).toHaveBeenCalled();
+      expect(mockClient.connect).toHaveBeenCalledWith({
+        requiredNamespaces: expect.any(Object),
+      });
+      expect(provider.uri).toBe("wc:new-uri");
+    });
+
+    it("should not create new URI when active sessions exist", async () => {
+      const mockSession = {
+        topic: "test-topic",
+        namespaces: {},
+      };
+      mockClient.getActiveSessions.mockReturnValue([mockSession]);
+
+      await provider.initialize();
+
+      expect(mockClient.initialize).toHaveBeenCalled();
+      expect(mockClient.connect).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("getUri", () => {
+    it("should return existing URI if available", async () => {
+      provider.uri = "wc:existing-uri";
+      const uri = await provider.getUri();
+
+      expect(uri).toBe("wc:existing-uri");
+      expect(mockClient.connect).not.toHaveBeenCalled();
+    });
+
+    it("should create new URI if not available", async () => {
+      mockClient.connect.mockResolvedValue("wc:new-uri");
+      const uri = await provider.getUri();
+
+      expect(uri).toBe("wc:new-uri");
+      expect(mockClient.connect).toHaveBeenCalled();
+      expect(provider.uri).toBe("wc:new-uri");
+    });
+  });
+
+  describe("connect", () => {
+    it("should connect and wait for session", async () => {
+      vi.useFakeTimers();
+      mockClient.connect.mockResolvedValue("wc:test-uri");
+      mockClient.getActiveSessions.mockReturnValueOnce([]).mockReturnValueOnce([
+        {
+          topic: "test-topic",
+          namespaces: {
+            eip155: {
+              accounts: ["eip155:1:0x123"],
+            },
+          },
+        },
+      ]);
+
+      const connectPromise = provider.connect();
+      // Simulate session establishment
+      setTimeout(() => {
+        const sessions = mockClient.getActiveSessions();
+        if (sessions.length > 0) {
+          // Trigger session_proposal handler
+          const handlers = (mockClient.on as any).mock.calls.filter((call: any[]) => call[0] === "session_proposal");
+          if (handlers.length > 0) {
+            handlers[0][1]();
+          }
+        }
+      }, 100);
+
+      vi.advanceTimersByTime(200);
+      const result = await connectPromise;
+
+      expect(result).toBeDefined();
+      vi.useRealTimers();
+    });
+
+    it("should emit error and return undefined when waitForConnection fails", async () => {
+      vi.useFakeTimers();
+      mockClient.getActiveSessions.mockReturnValue([]);
+      mockClient.connect.mockResolvedValue("wc:uri");
+      const connectPromise = provider.connect();
+      // Timeout is 300000ms; advance to trigger rejection
+      await vi.advanceTimersByTimeAsync(300001);
+      const result = await connectPromise;
+      expect(result).toBeUndefined();
+      vi.useRealTimers();
+    });
+  });
+
+  describe("disconnect", () => {
+    it("should disconnect session", async () => {
+      provider["session"] = {
+        topic: "test-topic",
+        namespaces: {},
+      } as any;
+
+      await provider.disconnect();
+
+      expect(mockClient.disconnectSession).toHaveBeenCalledWith("test-topic");
+      expect(provider["session"]).toBeNull();
+      expect(provider["accounts"]).toEqual([]);
+    });
+
+    it("should handle disconnect when not connected", async () => {
+      provider["session"] = null;
+
+      await provider.disconnect();
+
+      expect(mockClient.disconnectSession).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("request", () => {
+    it("should handle eth_requestAccounts when connected", async () => {
+      provider["session"] = {
+        topic: "test-topic",
+        namespaces: {},
+      } as any;
+      provider["accounts"] = ["0x123"];
+
+      const result = await provider.request({ method: "eth_requestAccounts" });
+
+      expect(result).toEqual(["0x123"]);
+    });
+
+    it("should handle eth_requestAccounts when not connected", async () => {
+      provider["session"] = null;
+      mockClient.connect.mockResolvedValue("wc:test-uri");
+      mockClient.getActiveSessions.mockReturnValue([]);
+
+      const resultPromise = provider.request({ method: "eth_requestAccounts" });
+
+      // Should trigger connect
+      expect(mockClient.connect).toHaveBeenCalled();
+    });
+
+    it("should handle eth_chainId", async () => {
+      provider["chainId"] = "0x5";
+      const result = await provider.request({ method: "eth_chainId" });
+
+      expect(result).toBe("0x5");
+    });
+
+    it("should send request to client", async () => {
+      provider["session"] = {
+        topic: "test-topic",
+        namespaces: {},
+      } as any;
+      provider["chainId"] = "0x1";
+
+      await provider.request({
+        method: "eth_getBalance",
+        params: ["0x123", "latest"],
+      });
+
+      expect(mockClient.sendRequest).toHaveBeenCalledWith({
+        topic: "test-topic",
+        chainId: "eip155:1",
+        request: {
+          method: "eth_getBalance",
+          params: ["0x123", "latest"],
+        },
+      });
+    });
+
+    it("should throw error when not connected", async () => {
+      provider["session"] = null;
+
+      await expect(
+        provider.request({
+          method: "eth_getBalance",
+          params: [],
+        }),
+      ).rejects.toThrow("Not connected");
+    });
+
+    it("should handle request errors", async () => {
+      provider["session"] = {
+        topic: "test-topic",
+        namespaces: {},
+      } as any;
+      mockClient.sendRequest.mockRejectedValue(new Error("Request failed"));
+
+      await expect(
+        provider.request({
+          method: "eth_getBalance",
+          params: [],
+        }),
+      ).rejects.toThrow("Request failed");
+    });
+  });
+
+  describe("getAccounts", () => {
+    it("should return accounts when connected", async () => {
+      provider["session"] = {
+        topic: "test-topic",
+        namespaces: {},
+      } as any;
+      provider["accounts"] = ["0x123", "0x456"];
+
+      const accounts = await provider.getAccounts();
+
+      expect(accounts).toEqual(["0x123", "0x456"]);
+    });
+
+    it("should return empty array when not connected", async () => {
+      provider["session"] = null;
+
+      const accounts = await provider.getAccounts();
+
+      expect(accounts).toEqual([]);
+    });
+  });
+
+  describe("getChainId", () => {
+    it("should return current chain ID", async () => {
+      provider["chainId"] = "0x5";
+      const chainId = await provider.getChainId();
+
+      expect(chainId).toBe("0x5");
+    });
+  });
+
+  describe("isConnected", () => {
+    it("should return true when connected", () => {
+      provider["session"] = {
+        topic: "test-topic",
+        namespaces: {},
+      } as any;
+      provider["accounts"] = ["0x123"];
+
+      expect(provider.isConnected()).toBe(true);
+    });
+
+    it("should return false when not connected", () => {
+      provider["session"] = null;
+      expect(provider.isConnected()).toBe(false);
+    });
+
+    it("should return false when no accounts", () => {
+      provider["session"] = {
+        topic: "test-topic",
+        namespaces: {},
+      } as any;
+      provider["accounts"] = [];
+
+      expect(provider.isConnected()).toBe(false);
+    });
+  });
+
+  describe("getSession", () => {
+    it("should return current session", () => {
+      const mockSession = {
+        topic: "test-topic",
+        namespaces: {},
+      } as any;
+      provider["session"] = mockSession;
+
+      expect(provider.getSession()).toBe(mockSession);
+    });
+
+    it("should return null when not connected", () => {
+      provider["session"] = null;
+
+      expect(provider.getSession()).toBeNull();
+    });
+  });
+
+  describe("event listeners", () => {
+    it("should add event listener", () => {
+      const listener = vi.fn();
+      provider.on("test-event", listener);
+
+      expect(provider["eventListeners"].has("test-event")).toBe(true);
+    });
+
+    it("should remove event listener", () => {
+      const listener = vi.fn();
+      provider.on("test-event", listener);
+      provider.off("test-event", listener);
+
+      expect(provider["eventListeners"].get("test-event")?.has(listener)).toBe(false);
+    });
+
+    it("should emit events to listeners", () => {
+      const listener = vi.fn();
+      provider.on("test-event", listener);
+
+      provider["emit"]("test-event", { data: "test" });
+
+      expect(listener).toHaveBeenCalledWith({ data: "test" });
+    });
+
+    it("should handle listener errors gracefully", () => {
+      const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const listener = vi.fn(() => {
+        throw new Error("Listener error");
+      });
+      provider.on("test-event", listener);
+
+      provider["emit"]("test-event", { data: "test" });
+
+      expect(consoleErrorSpy).toHaveBeenCalled();
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe("helper methods", () => {
+    beforeEach(() => {
+      provider["session"] = {
+        topic: "test-topic",
+        namespaces: {},
+      } as any;
+      provider["accounts"] = ["0x123"];
+    });
+
+    it("should sign message", async () => {
+      mockClient.sendRequest.mockResolvedValue("0xsignature");
+
+      const signature = await provider.signMessage("test message");
+
+      expect(signature).toBe("0xsignature");
+      expect(mockClient.sendRequest).toHaveBeenCalledWith({
+        topic: "test-topic",
+        chainId: "eip155:1",
+        request: {
+          method: "personal_sign",
+          params: ["test message", "0x123"],
+        },
+      });
+    });
+
+    it("should throw when signing message with no account", async () => {
+      provider["accounts"] = [];
+
+      await expect(provider.signMessage("test")).rejects.toThrow("No account connected");
+    });
+
+    it("should sign typed data", async () => {
+      mockClient.sendRequest.mockResolvedValue("0xsignature");
+      const typedData = { types: {}, domain: {}, message: {} };
+
+      const signature = await provider.signTypedData(typedData);
+
+      expect(signature).toBe("0xsignature");
+    });
+
+    it("should send transaction", async () => {
+      mockClient.sendRequest.mockResolvedValue("0xtxhash");
+      const transaction = { to: "0x456", value: "0x0" };
+
+      const txHash = await provider.sendTransaction(transaction);
+
+      expect(txHash).toBe("0xtxhash");
+    });
+
+    it("should throw error when switching chain", async () => {
+      await expect(provider.switchChain("0x5")).rejects.toThrow("Please reconnect to switch chains");
+    });
+  });
+
+  describe("updateAccountsFromSession", () => {
+    it("should update accounts from session", () => {
+      const mockSession = {
+        topic: "test-topic",
+        namespaces: {
+          eip155: {
+            accounts: ["eip155:1:0x123", "eip155:1:0x456"],
+          },
+        },
+      } as any;
+
+      provider["session"] = mockSession;
+      provider["updateAccountsFromSession"]();
+
+      expect(provider["accounts"]).toEqual(["0x123", "0x456"]);
+      expect(provider["chainId"]).toBe("0x1");
+    });
+
+    it("should handle empty accounts", () => {
+      const mockSession = {
+        topic: "test-topic",
+        namespaces: {
+          eip155: {
+            accounts: [],
+          },
+        },
+      } as any;
+
+      provider["session"] = mockSession;
+      provider["updateAccountsFromSession"]();
+
+      expect(provider["accounts"]).toEqual([]);
+    });
+  });
+});