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

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

@@ -0,0 +1,75 @@
+import { describe, it, expect } from "vitest";
+import { isWagmiConnector } from "../utils/wallet-config";
+
+describe("wallet-config", () => {
+  describe("isWagmiConnector", () => {
+    it("should return true for function (CreateConnectorFn)", () => {
+      const createConnectorFn = () => ({ id: "test", name: "Test", connect: () => {} });
+      expect(isWagmiConnector(createConnectorFn as any)).toBe(true);
+    });
+
+    it("should return true for object with createConnector method", () => {
+      expect(
+        isWagmiConnector({
+          createConnector: () => ({}),
+        } as any),
+      ).toBe(true);
+    });
+
+    it("should return true for object with connector methods and id/name but no WalletConfig props", () => {
+      expect(
+        isWagmiConnector({
+          id: "wagmi-1",
+          connect: () => {},
+          disconnect: () => {},
+        } as any),
+      ).toBe(true);
+      expect(
+        isWagmiConnector({
+          name: "Wagmi Wallet",
+          getAccounts: () => {},
+          getChainId: () => {},
+        } as any),
+      ).toBe(true);
+    });
+
+    it("should return false for full WalletConfig object", () => {
+      expect(
+        isWagmiConnector({
+          id: "w1",
+          name: "Wallet",
+          icon: "icon.png",
+          iconBackground: "#000",
+        } as any),
+      ).toBe(false);
+    });
+
+    it("should return false for null or undefined", () => {
+      expect(isWagmiConnector(null as any)).toBe(false);
+      expect(isWagmiConnector(undefined as any)).toBe(false);
+    });
+
+    it("should return false for non-object", () => {
+      expect(isWagmiConnector("string" as any)).toBe(false);
+      expect(isWagmiConnector(123 as any)).toBe(false);
+    });
+
+    it("should return false when object has connector methods but missing both id and name", () => {
+      expect(
+        isWagmiConnector({
+          connect: () => {},
+          disconnect: () => {},
+        } as any),
+      ).toBe(false);
+    });
+
+    it("should return false when object has id/name but no connector methods", () => {
+      expect(
+        isWagmiConnector({
+          id: "x",
+          name: "y",
+        } as any),
+      ).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,377 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { eip6963Wallets } from "../wallets/wallet-eip6963";
+import { ProviderProtocol } from "@tomo-inc/wallet-utils";
+
+describe("wallet-eip6963", () => {
+  let originalWindow: typeof window;
+  let originalAddEventListener: typeof window.addEventListener;
+  let originalRemoveEventListener: typeof window.removeEventListener;
+  let originalDispatchEvent: typeof window.dispatchEvent;
+
+  beforeEach(() => {
+    originalWindow = global.window;
+    originalAddEventListener = window.addEventListener;
+    originalRemoveEventListener = window.removeEventListener;
+    originalDispatchEvent = window.dispatchEvent;
+
+    // Mock window methods
+    global.window = {
+      ...window,
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+    } as any;
+  });
+
+  afterEach(() => {
+    global.window = originalWindow;
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  describe("eip6963Wallets", () => {
+    it("should return empty array when no providers announce", async () => {
+      vi.useFakeTimers();
+
+      const promise = eip6963Wallets();
+      vi.advanceTimersByTime(1000);
+      const result = await promise;
+
+      expect(result).toEqual([]);
+      expect(window.addEventListener).toHaveBeenCalled();
+      expect(window.dispatchEvent).toHaveBeenCalled();
+    });
+
+    it("should detect and return EIP6963 wallets", async () => {
+      vi.useFakeTimers();
+
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      const mockWalletInfo = {
+        uuid: "test-uuid",
+        name: "Test Wallet",
+        icon: "test-icon.png",
+        rdns: "com.test.wallet",
+      };
+
+      let eventHandler: ((event: CustomEvent) => void) | null = null;
+
+      (window.addEventListener as any).mockImplementation((event: string, handler: any) => {
+        if (event === "eip6963:announceProvider") {
+          eventHandler = handler;
+        }
+      });
+
+      const promise = eip6963Wallets();
+
+      // Simulate provider announcement
+      if (eventHandler) {
+        eventHandler({
+          detail: {
+            info: mockWalletInfo,
+            provider: mockProvider,
+          },
+        } as any);
+      }
+
+      vi.advanceTimersByTime(1000);
+      const result = await promise;
+
+      expect(result).toHaveLength(1);
+      expect(result[0].info.name).toBe("Test Wallet");
+      expect(result[0].info.uuid).toBe("com.test.wallet");
+      expect(result[0].connectors.evm?.protocol).toBe(ProviderProtocol.INJECT);
+      expect(result[0].connectors.evm?.provider).toBe(mockProvider);
+      expect(result[0].isInstalled).toBe(true);
+    });
+
+    it("should filter out invalid wallet info", async () => {
+      vi.useFakeTimers();
+
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      let eventHandler: ((event: CustomEvent) => void) | null = null;
+
+      (window.addEventListener as any).mockImplementation((event: string, handler: any) => {
+        if (event === "eip6963:announceProvider") {
+          eventHandler = handler;
+        }
+      });
+
+      const promise = eip6963Wallets();
+
+      // Simulate invalid provider announcement (missing uuid)
+      if (eventHandler) {
+        eventHandler({
+          detail: {
+            info: {
+              name: "Test Wallet",
+              icon: "test-icon.png",
+              rdns: "com.test.wallet",
+              // Missing uuid
+            },
+            provider: mockProvider,
+          },
+        } as any);
+      }
+
+      vi.advanceTimersByTime(1000);
+      const result = await promise;
+
+      expect(result).toHaveLength(0);
+    });
+
+    it("should filter out wallets without request method", async () => {
+      vi.useFakeTimers();
+
+      const mockWalletInfo = {
+        uuid: "test-uuid",
+        name: "Test Wallet",
+        icon: "test-icon.png",
+        rdns: "com.test.wallet",
+      };
+
+      let eventHandler: ((event: CustomEvent) => void) | null = null;
+
+      (window.addEventListener as any).mockImplementation((event: string, handler: any) => {
+        if (event === "eip6963:announceProvider") {
+          eventHandler = handler;
+        }
+      });
+
+      const promise = eip6963Wallets();
+
+      // Simulate provider announcement without request method
+      if (eventHandler) {
+        eventHandler({
+          detail: {
+            info: mockWalletInfo,
+            provider: {}, // No request method
+          },
+        } as any);
+      }
+
+      vi.advanceTimersByTime(1000);
+      const result = await promise;
+
+      expect(result).toHaveLength(0);
+    });
+
+    it("should deduplicate wallets by uuid", async () => {
+      vi.useFakeTimers();
+
+      const mockProvider1 = { request: vi.fn() };
+      const mockProvider2 = { request: vi.fn() };
+
+      const mockWalletInfo = {
+        uuid: "test-uuid",
+        name: "Test Wallet",
+        icon: "test-icon.png",
+        rdns: "com.test.wallet",
+      };
+
+      let eventHandler: ((event: CustomEvent) => void) | null = null;
+
+      (window.addEventListener as any).mockImplementation((event: string, handler: any) => {
+        if (event === "eip6963:announceProvider") {
+          eventHandler = handler;
+        }
+      });
+
+      const promise = eip6963Wallets();
+
+      // Simulate same wallet announcing twice
+      if (eventHandler) {
+        eventHandler({
+          detail: {
+            info: mockWalletInfo,
+            provider: mockProvider1,
+          },
+        } as any);
+
+        eventHandler({
+          detail: {
+            info: mockWalletInfo,
+            provider: mockProvider2,
+          },
+        } as any);
+      }
+
+      vi.advanceTimersByTime(1000);
+      const result = await promise;
+
+      expect(result).toHaveLength(1);
+    });
+
+    it("should handle errors in handleProviderAnnouncement", async () => {
+      vi.useFakeTimers();
+      let eventHandler: ((event: CustomEvent) => void) | null = null;
+      (window.addEventListener as any).mockImplementation((event: string, handler: any) => {
+        if (event === "eip6963:announceProvider") eventHandler = handler;
+      });
+      const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const promise = eip6963Wallets();
+      if (eventHandler) {
+        const badEvent = {
+          detail: {
+            get info() {
+              throw new Error("Invalid info");
+            },
+            provider: { request: vi.fn() },
+          },
+        };
+        eventHandler(badEvent as any);
+      }
+      vi.advanceTimersByTime(1000);
+      const result = await promise;
+      expect(result).toEqual([]);
+      expect(consoleWarnSpy).toHaveBeenCalled();
+    });
+
+    it("should handle dispatchEvent errors gracefully", async () => {
+      vi.useFakeTimers();
+
+      (window.dispatchEvent as any).mockImplementation(() => {
+        throw new Error("Dispatch error");
+      });
+
+      const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      const promise = eip6963Wallets();
+      vi.advanceTimersByTime(1000);
+      const result = await promise;
+
+      expect(result).toEqual([]);
+      expect(consoleWarnSpy).toHaveBeenCalled();
+      expect(window.removeEventListener).toHaveBeenCalled();
+    });
+
+    it("should use rdns as uuid when available", async () => {
+      vi.useFakeTimers();
+
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      const mockWalletInfo = {
+        uuid: "test-uuid",
+        name: "Test Wallet",
+        icon: "test-icon.png",
+        rdns: "com.test.wallet",
+      };
+
+      let eventHandler: ((event: CustomEvent) => void) | null = null;
+
+      (window.addEventListener as any).mockImplementation((event: string, handler: any) => {
+        if (event === "eip6963:announceProvider") {
+          eventHandler = handler;
+        }
+      });
+
+      const promise = eip6963Wallets();
+
+      if (eventHandler) {
+        eventHandler({
+          detail: {
+            info: mockWalletInfo,
+            provider: mockProvider,
+          },
+        } as any);
+      }
+
+      vi.advanceTimersByTime(1000);
+      const result = await promise;
+
+      expect(result[0].info.uuid).toBe("com.test.wallet");
+    });
+
+    it("should use encoded name as uuid when rdns is missing", async () => {
+      vi.useFakeTimers();
+
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      const mockWalletInfo = {
+        uuid: "test-uuid",
+        name: "Test Wallet",
+        icon: "test-icon.png",
+        // No rdns property
+      };
+
+      let eventHandler: ((event: CustomEvent) => void) | null = null;
+
+      (window.addEventListener as any).mockImplementation((event: string, handler: any) => {
+        if (event === "eip6963:announceProvider") {
+          eventHandler = handler;
+        }
+      });
+
+      const promise = eip6963Wallets();
+
+      // Trigger the event handler after a short delay to ensure listener is set up
+      vi.advanceTimersByTime(10);
+
+      // Trigger the event handler directly
+      if (eventHandler) {
+        eventHandler({
+          detail: {
+            info: mockWalletInfo,
+            provider: mockProvider,
+          },
+        } as any);
+      }
+
+      // Advance timers to trigger the timeout
+      vi.advanceTimersByTime(1000);
+      const result = await promise;
+
+      expect(result.length).toBeGreaterThan(0);
+      expect(result[0].info.uuid).toBe(encodeURIComponent("Test Wallet"));
+    });
+
+    it("should handle announcement handler errors gracefully", async () => {
+      vi.useFakeTimers();
+
+      const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      let eventHandler: ((event: CustomEvent) => void) | null = null;
+
+      (window.addEventListener as any).mockImplementation((event: string, handler: any) => {
+        if (event === "eip6963:announceProvider") {
+          eventHandler = handler;
+        }
+      });
+
+      const promise = eip6963Wallets();
+
+      // Trigger the event with invalid data that will cause an error in the handler
+      setTimeout(() => {
+        if (eventHandler) {
+          // Pass invalid data that will cause the handler to throw
+          // The handler checks for wallet?.uuid, wallet?.name, etc.
+          // Passing null will cause errors when accessing properties
+          eventHandler({
+            detail: {
+              info: null, // Invalid info - missing required fields
+              provider: null,
+            },
+          } as any);
+        }
+      }, 10);
+
+      vi.advanceTimersByTime(1000);
+      const result = await promise;
+
+      expect(result).toEqual([]);
+      // The error should be caught and logged by the handler's try-catch
+      // Note: The handler catches errors and logs them, so console.warn should be called
+      // But if the error happens before the try-catch, it might not be logged
+      // So we just verify the result is empty (error was handled)
+    });
+  });
+});

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

@@ -1,4 +1,4 @@
-import { ProviderStandard } from "@tomo-inc/wallet-utils";
+import { ProviderProtocol, ProviderStandard } from "@tomo-inc/wallet-utils";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { walletStandardWallets } from "../wallets/wallet-standard";
 
@@ -63,7 +63,7 @@ describe("wallet-standard", () => {
 
       expect(result.solanaWallets).toHaveLength(1);
       expect(result.solanaWallets[0].info.name).toBe("Solana Wallet");
-      expect(result.solanaWallets[0].connectors.solana?.protocol).toBe(ProviderStandard.WALLET_STANDARD);
+      expect(result.solanaWallets[0].connectors.solana?.protocol).toBe(ProviderProtocol.INJECT);
       expect(result.solanaWallets[0].isInstalled).toBe(true);
     });
 
@@ -86,7 +86,7 @@ describe("wallet-standard", () => {
 
       expect(result.aptosWallets).toHaveLength(1);
       expect(result.aptosWallets[0].info.name).toBe("Aptos Wallet");
-      expect(result.aptosWallets[0].connectors.aptos?.protocol).toBe(ProviderStandard.WALLET_STANDARD);
+      expect(result.aptosWallets[0].connectors.aptos?.protocol).toBe(ProviderProtocol.INJECT);
     });
 
     it("should detect Sui wallets", async () => {
@@ -210,6 +210,44 @@ describe("wallet-standard", () => {
       expect(result.solanaWallets).toHaveLength(1);
     });
 
+    it("should process delayed wallets when getWallets returns more after delay", async () => {
+      const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const firstBatch = [
+        {
+          name: "First Solana",
+          icon: "icon.png",
+          chains: ["solana:mainnet"],
+          features: {
+            "solana:signTransaction": {},
+            "solana:signMessage": {},
+            "standard:connect": { connect: vi.fn() },
+          },
+        },
+      ];
+      const secondBatch = [
+        ...firstBatch,
+        {
+          name: "Delayed Wallet",
+          icon: "delayed.png",
+          chains: [],
+          features: {},
+        },
+      ];
+      let getCallCount = 0;
+      const originalGet = mockWalletsAPI.get;
+      mockWalletsAPI.get = vi.fn().mockImplementation(() => {
+        getCallCount++;
+        return getCallCount === 1 ? firstBatch : secondBatch;
+      });
+      const promise = walletStandardWallets();
+      vi.advanceTimersByTime(500);
+      const result = await promise;
+      mockWalletsAPI.get = originalGet;
+      expect(result.solanaWallets).toHaveLength(1);
+      expect(result.solanaWallets[0].info.name).toBe("First Solana");
+      expect(consoleWarnSpy).toHaveBeenCalledWith("[wallet-standard] Processing delayed wallet:", "Delayed Wallet");
+    });
+
     it("should handle errors gracefully", async () => {
       const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});