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

package/src/__tests__/wallet-walletconnect.test.ts

@@ -0,0 +1,370 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { ProviderProtocol } from "@tomo-inc/wallet-utils";
+
+// Mock providers - use vi.hoisted to create mock classes
+const { MockWalletConnectProvider, MockWalletConnectSolanaProvider } = vi.hoisted(() => {
+  // Create mock instances factory
+  const createMockInstance = () => ({
+    initialize: vi.fn().mockResolvedValue(undefined),
+    connect: vi.fn().mockResolvedValue(["0x123"]),
+    disconnect: vi.fn().mockResolvedValue(undefined),
+    request: vi.fn().mockResolvedValue("result"),
+    on: vi.fn(),
+    off: vi.fn(),
+    uri: "wc:test-uri",
+  });
+
+  const createMockSolanaInstance = () => ({
+    initialize: vi.fn().mockResolvedValue(undefined),
+    connect: vi.fn().mockResolvedValue({ publicKey: "SolanaKey123" }),
+    disconnect: vi.fn().mockResolvedValue(undefined),
+    request: vi.fn().mockResolvedValue("result"),
+    on: vi.fn(),
+    off: vi.fn(),
+    uri: "wc:test-uri",
+  });
+
+  // Create constructor functions that return mock instances
+  // Using function declaration so they can be used with 'new'
+  function MockProvider() {
+    return createMockInstance();
+  }
+
+  function MockSolanaProvider() {
+    return createMockSolanaInstance();
+  }
+
+  // Wrap with vi.fn() to make them spyable while preserving constructor behavior
+  const MockProviderSpy = vi.fn(MockProvider);
+  const MockSolanaProviderSpy = vi.fn(MockSolanaProvider);
+
+  return {
+    MockWalletConnectProvider: MockProviderSpy,
+    MockWalletConnectSolanaProvider: MockSolanaProviderSpy,
+  };
+});
+
+vi.mock("../wallets/providers/WalletConnectProvider", () => ({
+  WalletConnectProvider: MockWalletConnectProvider,
+}));
+
+vi.mock("../wallets/providers/WalletConnectSolanaProvider", () => ({
+  WalletConnectSolanaProvider: MockWalletConnectSolanaProvider,
+}));
+
+describe("wallet-walletconnect", () => {
+  let originalFetch: typeof fetch;
+
+  beforeEach(async () => {
+    originalFetch = global.fetch;
+    vi.clearAllMocks();
+    // Reset module cache before each test
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    vi.restoreAllMocks();
+  });
+
+  describe("setWalletConnectConfig", () => {
+    it("should set wallet connect configuration", async () => {
+      const { setWalletConnectConfig } = await import("../wallets/wallet-walletconnect");
+      const config = {
+        projectId: "test-project-id",
+        metadata: {
+          name: "Test App",
+          description: "Test Description",
+          url: "https://test.com",
+          icons: ["https://test.com/icon.png"],
+        },
+      };
+
+      setWalletConnectConfig(config);
+
+      // Config is set internally, verify by calling walletConnectWallets
+      expect(() => setWalletConnectConfig(config)).not.toThrow();
+    });
+  });
+
+  describe("walletConnectWallets", () => {
+    it("should fetch and return WalletConnect wallets", async () => {
+      const { walletConnectWallets } = await import("../wallets/wallet-walletconnect");
+      const mockWallets = [
+        {
+          id: "walletconnect",
+          name: "WalletConnect",
+          icon: "wc-icon.png",
+        },
+      ];
+
+      global.fetch = vi.fn().mockResolvedValue({
+        json: vi.fn().mockResolvedValue({ data: mockWallets }),
+      });
+
+      const result = await walletConnectWallets();
+
+      expect(global.fetch).toHaveBeenCalledWith("https://web3-assets.tomo.inc/api/wallets?walletId=walletConnect");
+      expect(result).toHaveLength(1);
+      expect(result[0].info.name).toBe("WalletConnect");
+      expect(result[0].info.isWalletConnect).toBe(true);
+      expect(result[0].connectors.evm).toBeDefined();
+      expect(result[0].connectors.solana).toBeDefined();
+    });
+
+    it("should use custom baseUrl", async () => {
+      const { walletConnectWallets } = await import("../wallets/wallet-walletconnect");
+      const mockWallets = [
+        {
+          id: "walletconnect",
+          name: "WalletConnect",
+          icon: "wc-icon.png",
+        },
+      ];
+
+      global.fetch = vi.fn().mockResolvedValue({
+        json: vi.fn().mockResolvedValue({ data: mockWallets }),
+      });
+
+      const customBaseUrl = "https://custom-api.example.com";
+      await walletConnectWallets(customBaseUrl);
+
+      expect(global.fetch).toHaveBeenCalledWith(`${customBaseUrl}/api/wallets?walletId=walletConnect`);
+    });
+
+    it("should return cached wallets on second call", async () => {
+      const { walletConnectWallets } = await import("../wallets/wallet-walletconnect");
+      const mockWallets = [
+        {
+          id: "walletconnect",
+          name: "WalletConnect",
+          icon: "wc-icon.png",
+        },
+      ];
+
+      global.fetch = vi.fn().mockResolvedValue({
+        json: vi.fn().mockResolvedValue({ data: mockWallets }),
+      });
+
+      const result1 = await walletConnectWallets();
+      const result2 = await walletConnectWallets();
+
+      expect(global.fetch).toHaveBeenCalledTimes(1);
+      // Compare by info properties since provider objects are recreated
+      expect(result1.length).toBe(result2.length);
+      expect(result1[0].info.uuid).toBe(result2[0].info.uuid);
+      expect(result1[0].info.name).toBe(result2[0].info.name);
+    });
+
+    it("should return empty array when no wallets found", async () => {
+      const { walletConnectWallets } = await import("../wallets/wallet-walletconnect");
+      global.fetch = vi.fn().mockResolvedValue({
+        json: vi.fn().mockResolvedValue({ data: [] }),
+      });
+
+      const result = await walletConnectWallets();
+
+      expect(result).toEqual([]);
+    });
+
+    it("should create connectors with correct structure", async () => {
+      const { walletConnectWallets } = await import("../wallets/wallet-walletconnect");
+      const mockWallets = [
+        {
+          id: "walletconnect",
+          name: "WalletConnect",
+          icon: "wc-icon.png",
+          iconBackground: "#000000",
+        },
+      ];
+
+      global.fetch = vi.fn().mockResolvedValue({
+        json: vi.fn().mockResolvedValue({ data: mockWallets }),
+      });
+
+      const result = await walletConnectWallets();
+
+      expect(result[0].info.uuid).toBe("walletconnect");
+      expect(result[0].info.name).toBe("WalletConnect");
+      expect(result[0].info.icon).toBe("wc-icon.png");
+      if (result[0].info.iconBackground) {
+        expect(result[0].info.iconBackground).toBe("#000000");
+      }
+      expect(result[0].info.links.homepage).toBe("https://walletconnect.com");
+      expect(result[0].isInstalled).toBe(true);
+      expect(result[0].connectors.evm?.protocol).toBe(ProviderProtocol.WALLET_CONNECT);
+      expect(result[0].connectors.solana?.protocol).toBe(ProviderProtocol.WALLET_CONNECT);
+    });
+  });
+
+  describe("createWalletConnectEVMProvider", () => {
+    beforeEach(async () => {
+      const { setWalletConnectConfig } = await import("../wallets/wallet-walletconnect");
+      setWalletConnectConfig({
+        projectId: "test-project-id",
+        metadata: {
+          name: "Test App",
+          description: "Test Description",
+          url: "https://test.com",
+          icons: ["https://test.com/icon.png"],
+        },
+      });
+    });
+
+    it("should create EVM provider with lazy initialization", async () => {
+      const { createWalletConnectEVMProvider } = await import("../wallets/wallet-walletconnect");
+      const provider = createWalletConnectEVMProvider();
+
+      expect(provider.isWalletConnect).toBe(true);
+      expect(provider.getProvider).toBeDefined();
+      expect(provider.request).toBeDefined();
+      expect(provider.connect).toBeDefined();
+      expect(provider.disconnect).toBeDefined();
+    });
+
+    it("should initialize provider on first getProvider call", async () => {
+      const { createWalletConnectEVMProvider } = await import("../wallets/wallet-walletconnect");
+      const provider = createWalletConnectEVMProvider();
+      const providerInstance = await provider.getProvider();
+
+      expect(MockWalletConnectProvider).toHaveBeenCalled();
+      expect(providerInstance).toBeDefined();
+    });
+
+    it("should reuse provider instance on subsequent calls", async () => {
+      const { createWalletConnectEVMProvider } = await import("../wallets/wallet-walletconnect");
+      const provider = createWalletConnectEVMProvider();
+      const provider1 = await provider.getProvider();
+      const provider2 = await provider.getProvider();
+
+      expect(provider1).toBe(provider2);
+      expect(MockWalletConnectProvider).toHaveBeenCalledTimes(1);
+    });
+
+    it("should throw error when config is not set", async () => {
+      // Reset modules to clear config
+      vi.resetModules();
+
+      // Re-import to get fresh module state
+      const { createWalletConnectEVMProvider: createProvider } = await import("../wallets/wallet-walletconnect");
+
+      const provider = createProvider();
+      await expect(provider.getProvider()).rejects.toThrow("WalletConnect not configured");
+    });
+
+    it("should handle request method", async () => {
+      const { createWalletConnectEVMProvider } = await import("../wallets/wallet-walletconnect");
+      const provider = createWalletConnectEVMProvider();
+      const result = await provider.request({ method: "eth_chainId" });
+
+      expect(result).toBeDefined();
+    });
+
+    it("should handle connect method", async () => {
+      const { createWalletConnectEVMProvider } = await import("../wallets/wallet-walletconnect");
+      const provider = createWalletConnectEVMProvider();
+      const result = await provider.connect();
+
+      expect(result).toBeDefined();
+    });
+
+    it("should handle disconnect method", async () => {
+      const { createWalletConnectEVMProvider } = await import("../wallets/wallet-walletconnect");
+      const provider = createWalletConnectEVMProvider();
+      await provider.getProvider(); // Initialize first
+      await provider.disconnect();
+
+      // Should not throw
+      expect(true).toBe(true);
+    });
+
+    it("should return connectUri getter", async () => {
+      const { createWalletConnectEVMProvider } = await import("../wallets/wallet-walletconnect");
+      const provider = createWalletConnectEVMProvider();
+      await provider.getProvider(); // Initialize first
+
+      expect(provider.connectUri).toBe("wc:test-uri");
+    });
+
+    it("should handle event listeners", async () => {
+      const { createWalletConnectEVMProvider } = await import("../wallets/wallet-walletconnect");
+      const provider = createWalletConnectEVMProvider();
+      const listener = vi.fn();
+
+      provider.on("test-event", listener);
+      provider.off("test-event", listener);
+
+      expect(provider.on).toBeDefined();
+      expect(provider.off).toBeDefined();
+    });
+
+    it("should call providerInstance.on and off when provider already initialized", async () => {
+      const { createWalletConnectEVMProvider } = await import("../wallets/wallet-walletconnect");
+      const provider = createWalletConnectEVMProvider();
+      await provider.getProvider();
+      const listener = vi.fn();
+      provider.on("accountsChanged", listener);
+      provider.off("accountsChanged", listener);
+      const mockInstance = MockWalletConnectProvider.mock.results[0]?.value;
+      expect(mockInstance?.on).toHaveBeenCalledWith("accountsChanged", listener);
+      expect(mockInstance?.off).toHaveBeenCalledWith("accountsChanged", listener);
+    });
+
+    it("should no-op on/off when provider not yet initialized", async () => {
+      const { createWalletConnectEVMProvider } = await import("../wallets/wallet-walletconnect");
+      const provider = createWalletConnectEVMProvider();
+      expect(provider.connectUri).toBeNull();
+      provider.on("e", () => {});
+      provider.off("e", () => {});
+    });
+
+    it("should pass custom namespaces to createWalletConnectEVMProvider", async () => {
+      const { createWalletConnectEVMProvider } = await import("../wallets/wallet-walletconnect");
+      const provider = createWalletConnectEVMProvider({ eip155: { methods: ["eth_sign"] } } as any);
+      const p = await provider.getProvider();
+      expect(p).toBeDefined();
+    });
+  });
+
+  describe("createWalletConnectSolanaProvider (via connector)", () => {
+    beforeEach(async () => {
+      const { setWalletConnectConfig } = await import("../wallets/wallet-walletconnect");
+      setWalletConnectConfig({
+        projectId: "test-project-id",
+        metadata: {
+          name: "Test App",
+          description: "Test Description",
+          url: "https://test.com",
+          icons: ["https://test.com/icon.png"],
+        },
+      });
+    });
+
+    it("should create Solana provider with getProvider, request, connect, disconnect", async () => {
+      const { walletConnectWallets } = await import("../wallets/wallet-walletconnect");
+      global.fetch = vi.fn().mockResolvedValue({
+        json: vi.fn().mockResolvedValue({
+          data: [{ id: "wc", name: "WalletConnect", icon: "/icon.png" }],
+        }),
+      });
+      const connectors = await walletConnectWallets();
+      const solanaProvider = connectors[0].connectors.solana?.provider;
+      expect(solanaProvider).toBeDefined();
+      expect(solanaProvider.isWalletConnect).toBe(true);
+      expect(solanaProvider.connectUri).toBeNull();
+      solanaProvider.on("event", () => {});
+      solanaProvider.off("event", () => {});
+      const result = await solanaProvider.request({ method: "solana_signMessage" });
+      expect(result).toBeDefined();
+      await solanaProvider.connect();
+      expect(solanaProvider.connectUri).toBe("wc:test-uri");
+      const solanaListener = vi.fn();
+      solanaProvider.on("event", solanaListener);
+      solanaProvider.off("event", solanaListener);
+      const mockSolanaInstance = MockWalletConnectSolanaProvider.mock.results[0]?.value;
+      expect(mockSolanaInstance?.on).toHaveBeenCalledWith("event", solanaListener);
+      expect(mockSolanaInstance?.off).toHaveBeenCalledWith("event", solanaListener);
+      await solanaProvider.disconnect();
+    });
+  });
+});

package/src/__tests__/wallets/index.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+describe("wallets/index", () => {
+  let originalFetch: typeof fetch;
+
+  beforeEach(() => {
+    vi.resetModules();
+    originalFetch = global.fetch;
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    vi.restoreAllMocks();
+  });
+
+  describe("getAllWallets", () => {
+    it("should fetch wallets from default URL", async () => {
+      const mockWallets = [{ id: "1", name: "Wallet 1" }];
+      global.fetch = vi.fn().mockResolvedValue({
+        json: vi.fn().mockResolvedValue({ data: mockWallets }),
+      });
+
+      const { getAllWallets } = await import("../../wallets/index");
+      const result = await getAllWallets();
+      expect(global.fetch).toHaveBeenCalledWith("https://web3-assets.tomo.inc/api/wallets");
+      expect(result).toEqual(mockWallets);
+    });
+
+    it("should fetch wallets from custom base URL", async () => {
+      const mockWallets = [{ id: "2", name: "Wallet 2" }];
+      global.fetch = vi.fn().mockResolvedValue({
+        json: vi.fn().mockResolvedValue({ data: mockWallets }),
+      });
+
+      const { getAllWallets } = await import("../../wallets/index");
+      const customBaseUrl = "https://custom-api.example.com";
+      const result = await getAllWallets(customBaseUrl);
+      expect(global.fetch).toHaveBeenCalledWith(`${customBaseUrl}/api/wallets`);
+      expect(result).toEqual(mockWallets);
+    });
+  });
+});

package/src/type.ts

@@ -17,6 +17,9 @@ export interface WalletInfo {
   mobile?: {
     getUri?: (uri: string) => string;
     getDeeplink?: (dappUrl?: string, chainId?: number) => string | Promise<string>;
+    deeplinkTemplate?: {
+      deeplink?: string;
+    };
   };
   links: {
     homepage?: string;
@@ -45,6 +48,7 @@ export interface ConnectorProvider {
 
 export type ConnectorProviders = Partial<Record<ChainTypeEnum, ConnectorProvider | null>>;
 export interface Connector {
+  providers?: any;
   info: WalletInfo;
   isInstalled?: boolean;
   recommoned?: boolean;

package/src/utils/chainId.ts

@@ -11,17 +11,18 @@ export const isSameAddress = (addr1: "0x${string}", addr2: "0x${string}") => {
 export const getAllTypeChainIds = ({ chainId, chainType }: { chainId: string | number; chainType: string }) => {
   if (isHex(chainId)) {
     const chainIdHex = chainId;
-    chainId = fromHex(chainId, "number").toString();
+    const chainIdStr = fromHex(chainId, "number").toString();
     return {
-      chainId,
+      chainId: chainIdStr,
       chainIdHex,
-      chainUid: `${chainType}:${chainId}`,
+      chainUid: `${chainType}:${chainIdStr}`,
     };
   }
+  const chainIdStr = String(chainId);
   const chainIdHex = toHex(Number(chainId));
   return {
-    chainId,
+    chainId: chainIdStr,
     chainIdHex,
-    chainUid: `${chainType}:${chainId}`,
+    chainUid: `${chainType}:${chainIdStr}`,
   };
 };

package/src/utils/wallet-config.ts

@@ -5,11 +5,7 @@ import { WagmiWalletConfig, WalletConfig } from "../wallets/types";
  * WalletConfig requires: id, name, icon, iconBackground
  */
 function hasWalletConfigProperties(config: any): boolean {
-  if (!config || typeof config !== "object") {
-    return false;
-  }
-
-  // Check for required WalletConfig properties
+  // Caller ensures config is non-null object
   return (
     typeof config.id === "string" &&
     typeof config.name === "string" &&
@@ -25,10 +21,7 @@ function hasWalletConfigProperties(config: any): boolean {
  * 2. An object with createConnector method
  */
 function hasWagmiConnectorProperties(config: any): boolean {
-  if (!config || typeof config !== "object") {
-    return false;
-  }
-
+  // Caller ensures config is non-null object
   // Check if it has createConnector method (wagmi connector wrapper)
   if (typeof config.createConnector === "function") {
     return true;

package/src/wallet-api/connect.ts

@@ -59,6 +59,7 @@ export const connect = async (
       address = res?.accounts?.[0]?.address || "";
     }
     network = "mainnet-beta";
+    chainId = `solana:${network}`;
   }
 
   if (chainType === "aptos") {
@@ -197,8 +198,9 @@ export const connectMobile = async ({
   };
   if (useWalletConnect) {
     return connectWithWalletConnect();
-  } else if (mobile?.getDeeplink) {
-    const deeplink = await mobile?.getDeeplink?.(dappLink);
+  } else if (mobile?.deeplinkTemplate?.deeplink) {
+    // example phantom deeplink `https://phantom.app/ul/browse/${encodeURIComponent(dappLink)}?ref=${encodeURIComponent(dappLink)}`;
+    const deeplink = mobile?.deeplinkTemplate?.deeplink.replace("{dappUrl}", encodeURIComponent(dappLink));
     if (deeplink) {
       openUri(deeplink);
     }

package/src/wallets/detector.ts

@@ -47,7 +47,6 @@ export function getInjectedProvider({ flag, namespace }: { flag?: WalletProvider
   const _window = typeof window !== "undefined" ? (window as WindowProvider) : undefined;
   if (typeof _window === "undefined") {
     throw new Error("Window is not defined");
-    return;
   }
   if (namespace) {
     // prefer custom eip1193 namespaces
@@ -174,7 +173,7 @@ export function walletConfigAdapter(
   }
 }
 
-function tomoConnectorDector(wallet: WalletConfig): Connector {
+function tomoConnectorDector(wallet: WalletConfig & { links: any }): Connector {
   const evmNS = {
     namespace: wallet?.namespace || "",
     flag: wallet?.flag || "",
@@ -247,7 +246,7 @@ function tomoConnectorDector(wallet: WalletConfig): Connector {
       rdns: wallet?.rdns,
       deeplink: wallet?.deeplink,
       mobile: wallet?.mobile,
-      links: {
+      links: wallet?.links || {
         homepage: wallet?.downloadUrls?.qrCode || "",
         ios_install: wallet?.downloadUrls?.ios || "",
         android_install: wallet?.downloadUrls?.android || "",
@@ -299,5 +298,5 @@ export function connectorDector(wallet: WalletConfig, connectorType: WalletConne
   if (connectorType === "wagmi") {
     return wagmiConnectorDector(wallet as WagmiWalletConfig);
   }
-  return tomoConnectorDector(wallet);
+  return tomoConnectorDector(wallet as unknown as WalletConfig & { links: any });
 }

package/src/wallets/providers/WalletConnectProvider.ts

@@ -217,14 +217,15 @@ export class WalletConnectProvider {
       return this.connect();
     }
 
-    if (!this.session) {
-      throw new Error("Not connected. Please call connect() first.");
-    }
-
+    // eth_chainId doesn't require a session
     if (args.method === "eth_chainId") {
       return this.chainId || "0x1"; // default to Ethereum mainnet
     }
 
+    if (!this.session) {
+      throw new Error("Not connected. Please call connect() first.");
+    }
+
     try {
       const result = await this.client.sendRequest({
         topic: this.session.topic,

package/src/wallets/providers/WalletConnectSolanaProvider.ts

@@ -209,7 +209,7 @@ export class WalletConnectSolanaProvider {
     // solana_requestAccounts
     if (args.method === "solana_requestAccounts") {
       if (this.accounts.length > 0) {
-        return { publicKey: this.accounts[0] };
+        return this.accounts[0];
       }
       const accounts = await this.connect();
       return accounts;

package/src/wallets/wallet-eip6963.ts

@@ -26,7 +26,7 @@ export async function eip6963Wallets(): Promise<Connector[]> {
           typeof wallet?.uuid === "string" &&
           typeof wallet?.name === "string" &&
           typeof wallet?.icon === "string" &&
-          typeof wallet?.rdns === "string";
+          (wallet?.rdns === undefined || typeof wallet?.rdns === "string");
 
         if (wallet && provider && isInfoValid && typeof provider.request === "function") {
           const existingWallet = evmWallets.find((w) => w.info.uuid === wallet.uuid);

package/vitest.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from "vitest/config";
+import path from "path";
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      utils: path.resolve(__dirname, "./src/utils"),
+      type: path.resolve(__dirname, "./src/type"),
+    },
+  },
+  test: {
+    globals: true,
+    environment: "jsdom",
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: ["node_modules/", "dist/", "**/*.config.*", "**/__tests__/**", "**/*.test.ts", "**/*.spec.ts"],
+    },
+  },
+});