@tomo-inc/wallet-adaptor-base 0.0.20 → 0.0.22

package/src/__tests__/WalletConnectSolanaProvider.test.ts

@@ -0,0 +1,537 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { WalletConnectSolanaProvider } from "../wallets/providers/WalletConnectSolanaProvider";
+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("WalletConnectSolanaProvider", () => {
+  let provider: WalletConnectSolanaProvider;
+  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 WalletConnectSolanaProvider(config);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("constructor and client listeners", () => {
+    it("should create provider with default Solana 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: {
+          solana: { accounts: ["solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:SolanaKey456"] },
+        },
+      };
+      mockClient.getActiveSessions.mockReturnValue([mockSession]);
+      const sessionProposalHandler = (mockClient.on as any).mock.calls.find((c: any[]) => c[0] === "session_proposal")?.[1];
+      sessionProposalHandler();
+      expect(provider["session"]).toEqual(mockSession);
+      expect(provider["accounts"]).toEqual([{ publicKey: "SolanaKey456" }]);
+      expect(provider["chainId"]).toBe("solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp");
+    });
+
+    it("should handle session_delete and clear session", () => {
+      provider["session"] = { topic: "t", namespaces: {} } as any;
+      provider["accounts"] = [{ publicKey: "SolanaKey123" }];
+      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: { solana: { accounts: ["solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:SolanaKey789"] } },
+      } as any;
+      const sessionUpdateHandler = (mockClient.on as any).mock.calls.find((c: any[]) => c[0] === "session_update")?.[1];
+      provider["updateAccountsFromSession"] = vi.fn();
+      sessionUpdateHandler();
+      expect(provider["updateAccountsFromSession"]).toHaveBeenCalled();
+    });
+
+    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://solana-uri" });
+      expect(provider.uri).toBe("wc://solana-uri");
+    });
+
+    it("should use custom namespaces when provided", () => {
+      const customNamespaces = {
+        solana: {
+          chains: ["solana:devnet"],
+          methods: ["solana_getAccounts"],
+          events: [],
+        },
+      };
+
+      const customProvider = new WalletConnectSolanaProvider({
+        ...config,
+        namespaces: customNamespaces,
+      });
+
+      expect(customProvider).toBeDefined();
+    });
+  });
+
+  describe("initialize", () => {
+    it("should initialize client", async () => {
+      await provider.initialize();
+
+      expect(mockClient.initialize).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 return existing accounts if available", async () => {
+      provider["accounts"] = [{ publicKey: "SolanaKey123" }];
+
+      const result = await provider.connect();
+
+      expect(result).toEqual({ publicKey: "SolanaKey123" });
+    });
+
+    it("should connect and wait for session", async () => {
+      vi.useFakeTimers();
+      mockClient.connect.mockResolvedValue("wc:test-uri");
+      mockClient.getActiveSessions.mockReturnValueOnce([]).mockReturnValueOnce([
+        {
+          topic: "test-topic",
+          namespaces: {
+            solana: {
+              accounts: ["solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:SolanaKey123"],
+            },
+          },
+        },
+      ]);
+
+      const connectPromise = provider.connect();
+      setTimeout(() => {
+        const sessions = mockClient.getActiveSessions();
+        if (sessions.length > 0) {
+          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 return undefined and emit error when waitForConnection times out", async () => {
+      vi.useFakeTimers();
+      mockClient.getActiveSessions.mockReturnValue([]);
+      mockClient.connect.mockResolvedValue("wc:uri");
+      const connectPromise = provider.connect();
+      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 solana_requestAccounts when connected", async () => {
+      provider["session"] = {
+        topic: "test-topic",
+        namespaces: {},
+      } as any;
+      provider["accounts"] = [{ publicKey: "SolanaKey123" }];
+
+      const result = await provider.request({ method: "solana_requestAccounts" });
+
+      expect(result).toEqual({ publicKey: "SolanaKey123" });
+    });
+
+    it("should call connect when solana_requestAccounts and not connected", async () => {
+      vi.useFakeTimers();
+      provider["session"] = null;
+      provider["accounts"] = [];
+      mockClient.connect.mockResolvedValue("wc:uri");
+      mockClient.getActiveSessions.mockReturnValue([]);
+      const requestPromise = provider.request({ method: "solana_requestAccounts" });
+      expect(mockClient.connect).toHaveBeenCalled();
+      await vi.advanceTimersByTimeAsync(300001);
+      const result = await requestPromise;
+      expect(result).toBeUndefined();
+      vi.useRealTimers();
+    });
+
+    it("should handle solana_getAccounts", async () => {
+      provider["accounts"] = [{ publicKey: "SolanaKey123" }];
+
+      const result = await provider.request({ method: "solana_getAccounts" });
+
+      expect(result).toEqual([{ publicKey: "SolanaKey123" }]);
+    });
+
+    it("should send request to client", async () => {
+      provider["session"] = {
+        topic: "test-topic",
+        namespaces: {},
+      } as any;
+      provider["chainId"] = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+
+      await provider.request({
+        method: "solana_signMessage",
+        params: { message: "test", pubkey: "SolanaKey123" },
+      });
+
+      expect(mockClient.sendRequest).toHaveBeenCalledWith({
+        topic: "test-topic",
+        chainId: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+        request: {
+          method: "solana_signMessage",
+          params: { message: "test", pubkey: "SolanaKey123" },
+        },
+      });
+    });
+
+    it("should throw error when not connected", async () => {
+      provider["session"] = null;
+
+      await expect(
+        provider.request({
+          method: "solana_signMessage",
+          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: "solana_signMessage",
+          params: [],
+        }),
+      ).rejects.toThrow("Request failed");
+    });
+  });
+
+  describe("getAccounts", () => {
+    it("should return accounts when connected", async () => {
+      provider["session"] = {
+        topic: "test-topic",
+        namespaces: {},
+      } as any;
+      provider["accounts"] = [{ publicKey: "SolanaKey123" }];
+
+      const accounts = await provider.getAccounts();
+
+      expect(accounts).toEqual([{ publicKey: "SolanaKey123" }]);
+    });
+
+    it("should return empty array when not connected", async () => {
+      provider["session"] = null;
+
+      const accounts = await provider.getAccounts();
+
+      expect(accounts).toEqual([{ publicKey: "" }]);
+    });
+  });
+
+  describe("getChainId", () => {
+    it("should return current chain ID", async () => {
+      provider["chainId"] = "solana:devnet";
+      const chainId = await provider.getChainId();
+
+      expect(chainId).toBe("solana:devnet");
+    });
+  });
+
+  describe("isConnected", () => {
+    it("should return true when connected", () => {
+      provider["session"] = {
+        topic: "test-topic",
+        namespaces: {},
+      } as any;
+      provider["accounts"] = [{ publicKey: "SolanaKey123" }];
+
+      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["chainId"] = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+    });
+
+    it("should sign message", async () => {
+      mockClient.sendRequest.mockResolvedValue({ signature: "0xsignature" });
+
+      const signature = await provider.signMessage("test message", "SolanaKey123");
+
+      expect(signature).toBe("0xsignature");
+      expect(mockClient.sendRequest).toHaveBeenCalledWith({
+        topic: "test-topic",
+        chainId: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+        request: {
+          method: "solana_signMessage",
+          params: {
+            message: "test message",
+            pubkey: "SolanaKey123",
+          },
+        },
+      });
+    });
+
+    it("should sign transaction", async () => {
+      mockClient.sendRequest.mockResolvedValue({ signature: "0xsignature", transaction: "0xtx" });
+
+      const result = await provider.signTransaction("0xtransaction");
+
+      expect(result).toEqual({ signature: "0xsignature", transaction: "0xtx" });
+    });
+
+    it("should sign all transactions", async () => {
+      mockClient.sendRequest.mockResolvedValue({ transactions: ["0xtx1", "0xtx2"] });
+
+      const result = await provider.signAllTransactions(["0xtx1", "0xtx2"]);
+
+      expect(result).toEqual({ transactions: ["0xtx1", "0xtx2"] });
+    });
+
+    it("should sign and send transaction", async () => {
+      mockClient.sendRequest.mockResolvedValue({ signature: "0xsignature" });
+
+      const result = await provider.signAndSendTransaction("0xtransaction", { skipPreflight: true });
+
+      expect(result).toEqual({ signature: "0xsignature" });
+    });
+  });
+
+  describe("updateAccountsFromSession", () => {
+    it("should update accounts from session", () => {
+      const mockSession = {
+        topic: "test-topic",
+        namespaces: {
+          solana: {
+            accounts: ["solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:SolanaKey123"],
+          },
+        },
+      } as any;
+
+      provider["session"] = mockSession;
+      provider["updateAccountsFromSession"]();
+
+      expect(provider["accounts"]).toEqual([{ publicKey: "SolanaKey123" }]);
+      expect(provider["chainId"]).toBe("solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp");
+    });
+
+    it("should filter only Solana accounts", () => {
+      const mockSession = {
+        topic: "test-topic",
+        namespaces: {
+          solana: {
+            accounts: ["solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:SolanaKey123"],
+          },
+          eip155: {
+            accounts: ["eip155:1:0x123"],
+          },
+        },
+      } as any;
+
+      provider["session"] = mockSession;
+      provider["updateAccountsFromSession"]();
+
+      expect(provider["accounts"]).toEqual([{ publicKey: "SolanaKey123" }]);
+    });
+
+    it("should handle empty accounts", () => {
+      const mockSession = {
+        topic: "test-topic",
+        namespaces: {
+          solana: {
+            accounts: [],
+          },
+        },
+      } as any;
+
+      provider["session"] = mockSession;
+      provider["updateAccountsFromSession"]();
+
+      expect(provider["accounts"]).toEqual([]);
+    });
+  });
+});