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

package/src/__tests__/detector.test.ts

@@ -0,0 +1,402 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  hasInjectedProvider,
+  getInjectedProvider,
+  walletConfigAdapter,
+  connectorDector,
+  supportedWalletConfigTypes,
+} from "../wallets/detector";
+import { ProviderProtocol } from "@tomo-inc/wallet-utils";
+
+describe("detector", () => {
+  let originalWindow: typeof window;
+
+  beforeEach(() => {
+    originalWindow = global.window;
+  });
+
+  afterEach(() => {
+    global.window = originalWindow;
+    vi.restoreAllMocks();
+  });
+
+  describe("hasInjectedProvider", () => {
+    it("should return true when namespace provider exists", () => {
+      Object.defineProperty(global, "window", {
+        value: {
+          ethereum: {
+            isMetaMask: true,
+          },
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      expect(hasInjectedProvider({ namespace: "ethereum" })).toBe(true);
+    });
+
+    it("should return true when flag provider exists", () => {
+      Object.defineProperty(global, "window", {
+        value: {
+          ethereum: {
+            providers: [
+              {
+                isMetaMask: true,
+              },
+            ],
+          },
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      expect(hasInjectedProvider({ flag: "isMetaMask" })).toBe(true);
+    });
+
+    it("should return false when provider does not exist", () => {
+      Object.defineProperty(global, "window", {
+        value: {},
+        writable: true,
+        configurable: true,
+      });
+
+      expect(hasInjectedProvider({ namespace: "ethereum" })).toBe(false);
+      expect(hasInjectedProvider({ flag: "isMetaMask" })).toBe(false);
+    });
+
+    it("should return true when nested namespace provider exists", () => {
+      const nested = { request: vi.fn() };
+      Object.defineProperty(global, "window", {
+        value: { ethereum: { wallet: nested } },
+        writable: true,
+        configurable: true,
+      });
+      expect(hasInjectedProvider({ namespace: "ethereum.wallet" })).toBe(true);
+    });
+  });
+
+  describe("getInjectedProvider", () => {
+    it("should throw error when window is undefined", () => {
+      Object.defineProperty(global, "window", {
+        value: undefined,
+        writable: true,
+        configurable: true,
+      });
+
+      expect(() => getInjectedProvider({})).toThrow("Window is not defined");
+    });
+
+    it("should return nested namespace provider when available", () => {
+      const mockProvider = { request: vi.fn() };
+      Object.defineProperty(global, "window", {
+        value: { ethereum: { nested: mockProvider } },
+        writable: true,
+        configurable: true,
+      });
+      expect(getInjectedProvider({ namespace: "ethereum.nested" })).toBe(mockProvider);
+    });
+
+    it("should return namespace provider when available", () => {
+      const mockProvider = { request: vi.fn() };
+      Object.defineProperty(global, "window", {
+        value: {
+          ethereum: mockProvider,
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      expect(getInjectedProvider({ namespace: "ethereum" })).toBe(mockProvider);
+    });
+
+    it("should return flag provider when available", () => {
+      const mockProvider = { isMetaMask: true, request: vi.fn() };
+      Object.defineProperty(global, "window", {
+        value: {
+          ethereum: {
+            providers: [mockProvider],
+          },
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      expect(getInjectedProvider({ flag: "isMetaMask" })).toBe(mockProvider);
+    });
+
+    it("should return first provider from providers array", () => {
+      const mockProvider1 = { request: vi.fn() };
+      const mockProvider2 = { request: vi.fn() };
+      Object.defineProperty(global, "window", {
+        value: {
+          ethereum: {
+            providers: [mockProvider1, mockProvider2],
+          },
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      expect(getInjectedProvider({})).toBe(mockProvider1);
+    });
+
+    it("should return window.ethereum as fallback", () => {
+      const mockEthereum = { request: vi.fn() };
+      Object.defineProperty(global, "window", {
+        value: {
+          ethereum: mockEthereum,
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      expect(getInjectedProvider({})).toBe(mockEthereum);
+    });
+  });
+
+  describe("walletConfigAdapter", () => {
+    it("should return wallet config for tomo type", () => {
+      const walletConfig = { name: "Test", id: "test" };
+      expect(walletConfigAdapter(walletConfig as any, "tomo", [], "")).toBe(walletConfig);
+    });
+
+    it("should return wallet config for wagmi type when not a function", () => {
+      const walletConfig = { name: "Test", id: "test" };
+      expect(walletConfigAdapter(walletConfig as any, "wagmi", [], "")).toBe(walletConfig);
+    });
+
+    it("should return wallet config as default", () => {
+      const walletConfig = { name: "Test", id: "test" };
+      expect(walletConfigAdapter(walletConfig as any, "unknown" as any, [], "")).toBe(walletConfig);
+    });
+
+    it("should adapt wagmi CreateConnectorFn to WalletConfig when connectorType is wagmi", () => {
+      const createConnector = vi.fn().mockReturnValue({
+        id: "injected",
+        name: "Injected",
+        connect: vi.fn(),
+        disconnect: vi.fn(),
+      });
+      const allWallets: any[] = [
+        { id: "injected", name: "Injected", icon: "/injected.png", iconBackground: "#fff", namespace: "eip155" },
+      ];
+      const result = walletConfigAdapter(createConnector as any, "wagmi", allWallets, "https://base/");
+      expect(result.id).toBe("injected");
+      expect(result.name).toBe("Injected");
+      expect(createConnector).toHaveBeenCalled();
+    });
+
+    it("should find default wallet by name match (metamask/injected style) when id does not match", () => {
+      const createConnector = vi.fn().mockReturnValue({
+        id: "injected",
+        name: "Injected MetaMask",
+        connect: vi.fn(),
+        disconnect: vi.fn(),
+      });
+      const allWallets: any[] = [
+        { id: "metamask", name: "MetaMask", icon: "/mm.png", iconBackground: "#fff", namespace: "eip155" },
+      ];
+      const result = walletConfigAdapter(createConnector as any, "wagmi", allWallets, "https://base/");
+      expect(result.id).toBe("injected");
+      expect(result.name).toBe("Injected MetaMask");
+      expect(result.namespace).toBe("eip155");
+      expect(result.icon).toContain("/mm.png");
+    });
+  });
+
+  describe("connectorDector", () => {
+    it("should create connector with EVM provider", () => {
+      const mockProvider = { request: vi.fn() };
+      Object.defineProperty(global, "window", {
+        value: {
+          ethereum: mockProvider,
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      const walletConfig = {
+        id: "test-wallet",
+        name: "Test Wallet",
+        icon: "icon.png",
+        namespace: "ethereum",
+      };
+
+      const connector = connectorDector(walletConfig as any, "tomo");
+      expect(connector.info.name).toBe("Test Wallet");
+      expect(connector.connectors.evm).toBeDefined();
+      expect(connector.connectors.evm?.protocol).toBe(ProviderProtocol.INJECT);
+      expect(connector.connectors.evm?.provider).toBe(mockProvider);
+    });
+
+    it("should create connector with EVM provider using flag", () => {
+      const mockProvider = { isMetaMask: true, request: vi.fn() };
+      Object.defineProperty(global, "window", {
+        value: {
+          ethereum: {
+            providers: [mockProvider],
+          },
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      const walletConfig = {
+        id: "test-wallet",
+        name: "Test Wallet",
+        icon: "icon.png",
+        flag: "isMetaMask",
+      };
+
+      const connector = connectorDector(walletConfig as any, "tomo");
+      expect(connector.connectors.evm).toBeDefined();
+      expect(connector.connectors.evm?.protocol).toBe(ProviderProtocol.INJECT);
+    });
+
+    it("should create connector with Solana provider", () => {
+      const mockProvider = { request: vi.fn() };
+      Object.defineProperty(global, "window", {
+        value: {
+          solana: mockProvider,
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      const walletConfig = {
+        id: "test-wallet",
+        name: "Test Wallet",
+        icon: "icon.png",
+        solana: {
+          namespace: "solana",
+        },
+      };
+
+      const connector = connectorDector(walletConfig as any, "tomo");
+      expect(connector.connectors.solana).toBeDefined();
+      expect(connector.connectors.solana?.protocol).toBe(ProviderProtocol.INJECT);
+    });
+
+    it("should create connector with Aptos provider", () => {
+      const mockProvider = { request: vi.fn() };
+      Object.defineProperty(global, "window", {
+        value: {
+          aptos: mockProvider,
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      const walletConfig = {
+        id: "test-wallet",
+        name: "Test Wallet",
+        icon: "icon.png",
+        aptos: {
+          namespace: "aptos",
+        },
+      };
+
+      const connector = connectorDector(walletConfig as any, "tomo");
+      expect(connector.connectors.aptos).toBeDefined();
+      expect(connector.connectors.aptos?.protocol).toBe(ProviderProtocol.INJECT);
+    });
+
+    it("should create connector with Dogecoin provider", () => {
+      const mockProvider = { request: vi.fn() };
+      Object.defineProperty(global, "window", {
+        value: {
+          dogecoin: mockProvider,
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      const walletConfig = {
+        id: "test-wallet",
+        name: "Test Wallet",
+        icon: "icon.png",
+        dogecoin: {
+          namespace: "dogecoin",
+        },
+      };
+
+      const connector = connectorDector(walletConfig as any, "tomo");
+      expect(connector.connectors.dogecoin).toBeDefined();
+      expect(connector.connectors.dogecoin?.protocol).toBe(ProviderProtocol.INJECT);
+    });
+
+    it("should create connector without providers when not installed", () => {
+      Object.defineProperty(global, "window", {
+        value: {},
+        writable: true,
+        configurable: true,
+      });
+
+      const walletConfig = {
+        id: "test-wallet",
+        name: "Test Wallet",
+        icon: "icon.png",
+        namespace: "ethereum",
+      };
+
+      const connector = connectorDector(walletConfig as any, "tomo");
+      expect(connector.isInstalled).toBe(false);
+      expect(connector.connectors.evm?.provider).toBeUndefined();
+    });
+
+    it("should include download URLs in links", () => {
+      const walletConfig = {
+        id: "test-wallet",
+        name: "Test Wallet",
+        icon: "icon.png",
+        downloadUrls: {
+          qrCode: "https://example.com/qr",
+          ios: "https://example.com/ios",
+          android: "https://example.com/android",
+          chrome: "https://example.com/chrome",
+        },
+      };
+
+      const connector = connectorDector(walletConfig as any, "tomo");
+      expect(connector.info.links.homepage).toBe("https://example.com/qr");
+      expect(connector.info.links.ios_install).toBe("https://example.com/ios");
+      expect(connector.info.links.android_install).toBe("https://example.com/android");
+      expect(connector.info.links.chrome_install).toBe("https://example.com/chrome");
+    });
+  });
+
+  describe("supportedWalletConfigTypes", () => {
+    it("should have tomo and wagmi types", () => {
+      expect(supportedWalletConfigTypes.tomo).toBe(true);
+      expect(supportedWalletConfigTypes.wagmi).toBe(true);
+    });
+  });
+
+  describe("connectorDector with wagmi type", () => {
+    it("should create connector via wagmiConnectorDector when connectorType is wagmi", () => {
+      const mockConnector = {
+        id: "wagmi-injected",
+        name: "Injected",
+        connect: vi.fn(),
+        disconnect: vi.fn(),
+      };
+      const wagmiWalletConfig = {
+        id: "wagmi-injected",
+        name: "Injected",
+        icon: "icon.png",
+        iconBackground: "#000",
+        createConnector: vi.fn().mockReturnValue(mockConnector),
+      } as any;
+
+      const connector = connectorDector(wagmiWalletConfig, "wagmi");
+
+      expect(connector.info.uuid).toBe("wagmi-injected");
+      expect(connector.info.name).toBe("Injected");
+      expect(connector.connectors.evm).toBeDefined();
+      expect(connector.connectors.evm?.protocol).toBe(ProviderProtocol.INJECT);
+      expect(connector.connectors.evm?.provider).toBe(mockConnector);
+      expect(connector.isInstalled).toBe(true);
+      expect(wagmiWalletConfig.createConnector).toHaveBeenCalled();
+    });
+  });
+});

package/src/__tests__/index.test.ts

@@ -0,0 +1,275 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { loadConnectors, isMobile } from "../index";
+
+// Mock dependencies - use vi.hoisted to define variables that can be used in vi.mock
+const { mockEip6963Wallet, mockSolanaWallet, mockDefaultConnector, mockEip6963ConnectorFromConfig } = vi.hoisted(() => {
+  const mockEip6963Wallet = {
+    info: { name: "EIP6963 Wallet", uuid: "eip6963-1", icon: "icon1.png" },
+    connectors: { evm: { provider: {}, protocol: "eip6963" } },
+    isInstalled: false,
+  };
+
+  const mockSolanaWallet = {
+    info: { name: "Solana Wallet", uuid: "solana-1", icon: "icon2.png" },
+    connectors: { solana: { provider: {}, protocol: "inject" } },
+    isInstalled: false,
+  };
+
+  const mockDefaultConnector = {
+    info: { name: "Default Wallet", uuid: "default-1", icon: "icon3.png" },
+    connectors: { evm: { provider: {}, protocol: "eip6963" } },
+    isInstalled: false,
+    recommoned: true,
+  };
+
+  // Add a connector with same name as detected wallet so it gets marked as installed
+  const mockEip6963ConnectorFromConfig = {
+    info: { name: "EIP6963 Wallet", uuid: "eip6963-1", icon: "icon1.png" },
+    connectors: { evm: { provider: {}, protocol: "eip6963" } },
+    isInstalled: false,
+  };
+
+  return { mockEip6963Wallet, mockSolanaWallet, mockDefaultConnector, mockEip6963ConnectorFromConfig };
+});
+
+vi.mock("../wallets/wallet-eip6963", () => ({
+  eip6963Wallets: vi.fn().mockResolvedValue([mockEip6963Wallet]),
+}));
+
+vi.mock("../wallets/wallet-standard", () => ({
+  walletStandardWallets: vi.fn().mockResolvedValue({
+    solanaWallets: [mockSolanaWallet],
+    aptosWallets: [],
+  }),
+}));
+
+vi.mock("../wallets/wallet-walletconnect", () => ({
+  walletConnectWallets: vi.fn().mockResolvedValue([]),
+}));
+
+vi.mock("../wallets/defaultConnectors", () => ({
+  getDefaultConnectors: vi.fn().mockResolvedValue([mockDefaultConnector, mockEip6963ConnectorFromConfig]),
+}));
+
+vi.mock("../wallets", () => ({
+  getAllWallets: vi.fn().mockResolvedValue([]),
+  walletBaseUrl: "https://web3-assets.tomo.inc",
+}));
+
+describe("wallet-adaptor-base", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("loadConnectors", () => {
+    it("should load connectors with default options", async () => {
+      const result = await loadConnectors({});
+      expect(result.all).toBeDefined();
+      expect(result.recommoned).toBeDefined();
+      expect(Array.isArray(result.all)).toBe(true);
+      expect(Array.isArray(result.recommoned)).toBe(true);
+    });
+
+    it("should filter connectors by chain type", async () => {
+      const result = await loadConnectors({ chainType: "evm" });
+      expect(result.all).toBeDefined();
+    });
+
+    it("should handle recommoned connectors", async () => {
+      const recommonedConnectors = [
+        {
+          name: "Test Wallet",
+          icon: "https://example.com/icon.png",
+          id: "test-wallet",
+        },
+      ];
+
+      const result = await loadConnectors({
+        recommendedConnectors: recommonedConnectors as any,
+        connectorTypes: ["tomo"],
+      });
+
+      expect(result.recommoned).toBeDefined();
+    });
+
+    it("should throw error for unsupported connector type", async () => {
+      await expect(
+        loadConnectors({
+          recommendedConnectors: [{}] as any,
+          connectorTypes: ["unsupported" as any],
+        }),
+      ).rejects.toThrow("Unsupported wallet config type: unsupported");
+    });
+
+    it("should merge detected connectors with config connectors", async () => {
+      const result = await loadConnectors({});
+      // Should include both detected wallets and default connectors
+      expect(result.all.length).toBeGreaterThan(0);
+    });
+
+    it("should mark connectors as installed when detected", async () => {
+      const result = await loadConnectors({});
+      const eip6963Connector = result.all.find((c) => c.info.name === "EIP6963 Wallet");
+      if (eip6963Connector) {
+        expect(eip6963Connector.isInstalled).toBe(true);
+      }
+    });
+
+    it("should sort connectors with recommoned first", async () => {
+      const result = await loadConnectors({});
+      const recommonedIndex = result.all.findIndex((c) => c.recommoned);
+      const nonRecommonedIndex = result.all.findIndex((c) => !c.recommoned);
+      if (recommonedIndex !== -1 && nonRecommonedIndex !== -1) {
+        expect(recommonedIndex).toBeLessThan(nonRecommonedIndex);
+      }
+    });
+
+    it("should sort connectors with installed wallets second", async () => {
+      const result = await loadConnectors({});
+      // Check that installed wallets come before non-installed
+      const installedIndex = result.all.findIndex((c) => c.isInstalled);
+      const nonInstalledIndex = result.all.findIndex((c) => !c.isInstalled && !c.recommoned);
+      if (installedIndex !== -1 && nonInstalledIndex !== -1) {
+        expect(installedIndex).toBeLessThan(nonInstalledIndex);
+      }
+    });
+
+    it("should filter by solana chain type", async () => {
+      const result = await loadConnectors({ chainType: "solana" });
+      expect(result.all.every((c) => c.connectors.solana)).toBe(true);
+    });
+
+    it("should filter by aptos chain type", async () => {
+      const { walletStandardWallets } = await import("../wallets/wallet-standard");
+      vi.mocked(walletStandardWallets).mockResolvedValueOnce({
+        solanaWallets: [],
+        aptosWallets: [
+          {
+            info: { name: "Aptos Wallet", uuid: "aptos-1" },
+            connectors: { aptos: { provider: {}, protocol: "inject" } },
+            isInstalled: false,
+          },
+        ],
+        suiWallets: [],
+      });
+
+      const result = await loadConnectors({ chainType: "aptos" });
+      expect(result.all.every((c) => c.connectors.aptos)).toBe(true);
+    });
+
+    it("should use custom baseUrl", async () => {
+      const { getDefaultConnectors } = await import("../wallets/defaultConnectors");
+      const { walletConnectWallets } = await import("../wallets/wallet-walletconnect");
+
+      await loadConnectors({
+        options: {
+          baseUrl: "https://custom-api.example.com",
+        },
+      });
+
+      // Verify custom baseUrl is passed to functions
+      expect(vi.mocked(getDefaultConnectors)).toHaveBeenCalledWith("https://custom-api.example.com");
+      expect(vi.mocked(walletConnectWallets)).toHaveBeenCalledWith("https://custom-api.example.com");
+    });
+
+    it("should merge providers when connector already exists", async () => {
+      const mockWalletConnectWallet = {
+        info: { name: "EIP6963 Wallet", uuid: "eip6963-1" },
+        connectors: { evm: { provider: { wc: true }, protocol: "walletconnect" } },
+        isInstalled: false,
+      };
+
+      const { walletConnectWallets } = await import("../wallets/wallet-walletconnect");
+      vi.mocked(walletConnectWallets).mockResolvedValueOnce([mockWalletConnectWallet as any]);
+
+      const result = await loadConnectors({});
+      const connector = result.all.find((c) => c.info.name === "EIP6963 Wallet");
+
+      if (connector) {
+        // Should merge connectors
+        expect(connector.connectors.evm).toBeDefined();
+      }
+    });
+
+    it("should handle empty recommoned connectors", async () => {
+      const result = await loadConnectors({
+        recommendedConnectors: [],
+        connectorTypes: [],
+      });
+
+      expect(result.recommoned).toEqual([]);
+    });
+
+    it("should handle multiple recommoned connectors", async () => {
+      const recommonedConnectors = [
+        {
+          name: "Wallet 1",
+          icon: "icon1.png",
+          id: "wallet-1",
+        },
+        {
+          name: "Wallet 2",
+          icon: "icon2.png",
+          id: "wallet-2",
+        },
+      ];
+
+      const result = await loadConnectors({
+        recommendedConnectors: recommonedConnectors as any,
+        connectorTypes: ["tomo", "tomo"],
+      });
+
+      expect(result.recommoned).toHaveLength(2);
+      expect(result.recommoned.every((c) => c.recommoned)).toBe(true);
+    });
+
+    it("should handle WalletConnect wallets", async () => {
+      const mockWCWallet = {
+        info: { name: "WalletConnect", uuid: "wc-1" },
+        providers: { evm: { provider: {}, protocol: "walletconnect" } },
+        isInstalled: true,
+      };
+
+      const { walletConnectWallets } = await import("../wallets/wallet-walletconnect");
+      vi.mocked(walletConnectWallets).mockResolvedValueOnce([mockWCWallet as any]);
+
+      const result = await loadConnectors({});
+      const wcConnector = result.all.find((c) => c.info.name === "WalletConnect");
+
+      expect(wcConnector).toBeDefined();
+      if (wcConnector) {
+        expect(wcConnector.isInstalled).toBe(true);
+      }
+    });
+
+    it("should handle all chain type", async () => {
+      const result = await loadConnectors({ chainType: "all" });
+      // Should include all connectors regardless of chain type
+      expect(result.all.length).toBeGreaterThan(0);
+    });
+
+    it("should handle empty detected wallets", async () => {
+      const { eip6963Wallets } = await import("../wallets/wallet-eip6963");
+      const { walletStandardWallets } = await import("../wallets/wallet-standard");
+      const { walletConnectWallets } = await import("../wallets/wallet-walletconnect");
+
+      vi.mocked(eip6963Wallets).mockResolvedValueOnce([]);
+      vi.mocked(walletStandardWallets).mockResolvedValueOnce({
+        solanaWallets: [],
+        aptosWallets: [],
+        suiWallets: [],
+      });
+      vi.mocked(walletConnectWallets).mockResolvedValueOnce([]);
+
+      const result = await loadConnectors({});
+      // Should still return default connectors
+      expect(result.all.length).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe("isMobile", () => {
+    it("should export isMobile function", () => {
+      expect(typeof isMobile).toBe("function");
+    });
+  });
+});