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

package/src/__tests__/browsers.test.ts

@@ -0,0 +1,263 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { isSafari, isArc, getBrowser, BrowserType, openUri } from "../utils/browsers";
+
+describe("browsers", () => {
+  let originalNavigator: typeof navigator;
+  let originalDocument: typeof document;
+  let originalWindow: typeof window;
+
+  beforeEach(() => {
+    originalNavigator = global.navigator;
+    originalDocument = global.document;
+    originalWindow = global.window;
+  });
+
+  afterEach(() => {
+    global.navigator = originalNavigator;
+    global.document = originalDocument;
+    global.window = originalWindow;
+    vi.restoreAllMocks();
+  });
+
+  describe("isSafari", () => {
+    it("should return true for Safari user agent", () => {
+      Object.defineProperty(global, "navigator", {
+        value: {
+          userAgent:
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Safari/605.1.15",
+        },
+        writable: true,
+        configurable: true,
+      });
+      expect(isSafari()).toBe(true);
+    });
+
+    it("should return false for non-Safari user agent", () => {
+      Object.defineProperty(global, "navigator", {
+        value: {
+          userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+        },
+        writable: true,
+        configurable: true,
+      });
+      expect(isSafari()).toBe(false);
+    });
+
+    it("should return false when navigator is undefined", () => {
+      Object.defineProperty(global, "navigator", {
+        value: undefined,
+        writable: true,
+        configurable: true,
+      });
+      expect(isSafari()).toBe(false);
+    });
+  });
+
+  describe("isArc", () => {
+    it("should return true when Arc CSS variable is present", () => {
+      const mockGetComputedStyle = vi.fn(() => ({
+        getPropertyValue: vi.fn((prop: string) => {
+          if (prop === "--arc-palette-focus") return "some-value";
+          return "";
+        }),
+      }));
+
+      Object.defineProperty(global, "document", {
+        value: {
+          body: {},
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      global.getComputedStyle = mockGetComputedStyle as any;
+      expect(isArc()).toBe(true);
+    });
+
+    it("should return false when Arc CSS variable is not present", () => {
+      const mockGetComputedStyle = vi.fn(() => ({
+        getPropertyValue: vi.fn(() => ""),
+      }));
+
+      Object.defineProperty(global, "document", {
+        value: {
+          body: {},
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      global.getComputedStyle = mockGetComputedStyle as any;
+      expect(isArc()).toBe(false);
+    });
+
+    it("should return false when document is undefined", () => {
+      Object.defineProperty(global, "document", {
+        value: undefined,
+        writable: true,
+        configurable: true,
+      });
+      expect(isArc()).toBe(false);
+    });
+  });
+
+  describe("getBrowser", () => {
+    it("should return BrowserType.Browser when navigator is undefined", () => {
+      Object.defineProperty(global, "navigator", {
+        value: undefined,
+        writable: true,
+        configurable: true,
+      });
+      expect(getBrowser()).toBe(BrowserType.Browser);
+    });
+
+    it("should return BrowserType.Brave when brave.isBrave is true", () => {
+      Object.defineProperty(global, "navigator", {
+        value: {
+          userAgent: "test",
+          brave: {
+            isBrave: true,
+          },
+        },
+        writable: true,
+        configurable: true,
+      });
+      expect(getBrowser()).toBe(BrowserType.Brave);
+    });
+
+    it("should return BrowserType.Edge for Edge user agent", () => {
+      Object.defineProperty(global, "navigator", {
+        value: {
+          userAgent:
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36 Edg/91.0.864.59",
+        },
+        writable: true,
+        configurable: true,
+      });
+      expect(getBrowser()).toBe(BrowserType.Edge);
+    });
+
+    it("should return BrowserType.Opera for Opera user agent", () => {
+      Object.defineProperty(global, "navigator", {
+        value: {
+          userAgent:
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36 OPR/77.0.4054.203",
+        },
+        writable: true,
+        configurable: true,
+      });
+      expect(getBrowser()).toBe(BrowserType.Opera);
+    });
+
+    it("should return BrowserType.Chrome for Chrome user agent", () => {
+      Object.defineProperty(global, "navigator", {
+        value: {
+          userAgent:
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+        },
+        writable: true,
+        configurable: true,
+      });
+      expect(getBrowser()).toBe(BrowserType.Chrome);
+    });
+
+    it("should return BrowserType.Firefox for Firefox user agent", () => {
+      Object.defineProperty(global, "navigator", {
+        value: {
+          userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0",
+        },
+        writable: true,
+        configurable: true,
+      });
+      expect(getBrowser()).toBe(BrowserType.Firefox);
+    });
+
+    it("should return BrowserType.Safari for Safari user agent", () => {
+      Object.defineProperty(global, "navigator", {
+        value: {
+          userAgent:
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Safari/605.1.15",
+        },
+        writable: true,
+        configurable: true,
+      });
+      expect(getBrowser()).toBe(BrowserType.Safari);
+    });
+
+    it("should return BrowserType.Arc when Arc CSS variable is present", () => {
+      const mockGetComputedStyle = vi.fn(() => ({
+        getPropertyValue: vi.fn((prop: string) => (prop === "--arc-palette-focus" ? "some-value" : "")),
+      }));
+      Object.defineProperty(global, "navigator", {
+        value: { userAgent: "Mozilla/5.0 (generic) Chrome/120.0", brave: undefined },
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(global, "document", {
+        value: { body: {}, createElement: document.createElement?.bind(document) },
+        writable: true,
+        configurable: true,
+      });
+      (global as any).getComputedStyle = mockGetComputedStyle;
+      expect(getBrowser()).toBe(BrowserType.Arc);
+    });
+
+    it("should return BrowserType.Browser when no known browser matches", () => {
+      Object.defineProperty(global, "navigator", {
+        value: {
+          userAgent: "Mozilla/5.0 (compatible; UnknownBot/1.0)",
+          brave: undefined,
+        },
+        writable: true,
+        configurable: true,
+      });
+      const mockGetComputedStyle = vi.fn(() => ({
+        getPropertyValue: vi.fn(() => ""),
+      }));
+      (global as any).getComputedStyle = mockGetComputedStyle;
+      expect(getBrowser()).toBe(BrowserType.Browser);
+    });
+  });
+
+  describe("openUri", () => {
+    it("should open http URI in new tab", () => {
+      const mockClick = vi.fn();
+      const mockLink = {
+        href: "",
+        target: "",
+        rel: "",
+        click: mockClick,
+      };
+      const mockCreateElement = vi.fn(() => mockLink);
+
+      Object.defineProperty(global, "document", {
+        value: {
+          createElement: mockCreateElement,
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      openUri("https://example.com");
+      expect(mockCreateElement).toHaveBeenCalledWith("a");
+      expect(mockLink.href).toBe("https://example.com");
+      expect(mockLink.target).toBe("_blank");
+      expect(mockLink.rel).toBe("noreferrer noopener");
+      expect(mockClick).toHaveBeenCalled();
+    });
+
+    it("should navigate to non-http URI", () => {
+      const mockLocation = { href: "" };
+      Object.defineProperty(global, "window", {
+        value: {
+          location: mockLocation,
+        },
+        writable: true,
+        configurable: true,
+      });
+
+      openUri("custom://protocol");
+      expect(mockLocation.href).toBe("custom://protocol");
+    });
+  });
+});

package/src/__tests__/chainId.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+import { isHexChainId, isSameAddress, getAllTypeChainIds } from "../utils/chainId";
+
+describe("chainId", () => {
+  describe("isHexChainId", () => {
+    it("should return true for valid hex chain ID", () => {
+      expect(isHexChainId("0x1")).toBe(true);
+      expect(isHexChainId("0x01")).toBe(true);
+      expect(isHexChainId("0x123abc")).toBe(true);
+    });
+
+    it("should return false for invalid hex chain ID", () => {
+      expect(isHexChainId("1")).toBe(false);
+      expect(isHexChainId("0xgh")).toBe(false);
+      expect(isHexChainId("")).toBe(false);
+    });
+  });
+
+  describe("isSameAddress", () => {
+    it("should return true for same addresses", () => {
+      // Use valid Ethereum addresses (40 hex characters)
+      const addr1 = "0x1234567890123456789012345678901234567890";
+      const addr2 = "0x1234567890123456789012345678901234567890";
+      expect(isSameAddress(addr1, addr2)).toBe(true);
+      expect(
+        isSameAddress("0xAbCdEf1234567890123456789012345678901234", "0xabcdef1234567890123456789012345678901234"),
+      ).toBe(true); // Case insensitive
+    });
+
+    it("should return false for different addresses", () => {
+      const addr1 = "0x1234567890123456789012345678901234567890";
+      const addr2 = "0x9876543210987654321098765432109876543210";
+      expect(isSameAddress(addr1, addr2)).toBe(false);
+    });
+  });
+
+  describe("getAllTypeChainIds", () => {
+    it("should convert hex chain ID to number and hex", () => {
+      const result = getAllTypeChainIds({ chainId: "0x1", chainType: "evm" });
+      expect(result.chainId).toBe("1");
+      expect(result.chainIdHex).toBe("0x1");
+      expect(result.chainUid).toBe("evm:1");
+    });
+
+    it("should convert number chain ID to hex", () => {
+      const result = getAllTypeChainIds({ chainId: 1, chainType: "evm" });
+      expect(result.chainId).toBe("1");
+      expect(result.chainIdHex).toBe("0x1");
+      expect(result.chainUid).toBe("evm:1");
+    });
+
+    it("should convert string number chain ID to hex", () => {
+      const result = getAllTypeChainIds({ chainId: "56", chainType: "bsc" });
+      expect(result.chainId).toBe("56");
+      expect(result.chainIdHex).toBe("0x38");
+      expect(result.chainUid).toBe("bsc:56");
+    });
+
+    it("should handle large chain IDs", () => {
+      const result = getAllTypeChainIds({ chainId: "0x89", chainType: "polygon" });
+      expect(result.chainId).toBe("137");
+      expect(result.chainIdHex).toBe("0x89");
+      expect(result.chainUid).toBe("polygon:137");
+    });
+  });
+});

package/src/__tests__/chains-utils.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { chainInfoAdapter } from "../chains/utils";
+
+describe("chains/utils", () => {
+  let originalConsoleLog: typeof console.log;
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    originalConsoleLog = console.log;
+    consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    console.log = originalConsoleLog;
+    vi.restoreAllMocks();
+  });
+
+  describe("chainInfoAdapter", () => {
+    it("should return null for wagmi type", () => {
+      const chainConfig = { id: 1, name: "Ethereum" };
+      const result = chainInfoAdapter(chainConfig as any, "wagmi", "evm");
+      expect(result).toBeNull();
+    });
+
+    it("should return null for tomo type", () => {
+      const chainConfig = { id: 1, name: "Ethereum" };
+      const result = chainInfoAdapter(chainConfig as any, "tomo", "evm");
+      expect(result).toBeNull();
+    });
+
+    it("should return null for default case", () => {
+      const chainConfig = { id: 1, name: "Ethereum" };
+      const result = chainInfoAdapter(chainConfig as any, "unknown", "evm");
+      expect(result).toBeNull();
+    });
+
+    it("should log chainConfig for evm chainType", () => {
+      const chainConfig = { id: 1, name: "Ethereum" };
+      chainInfoAdapter(chainConfig as any, "wagmi", "evm");
+      expect(consoleLogSpy).toHaveBeenCalledWith(chainConfig);
+    });
+
+    it("should not log for non-evm chainType", () => {
+      const chainConfig = { id: 1, name: "Solana" };
+      chainInfoAdapter(chainConfig as any, "wagmi", "solana");
+      expect(consoleLogSpy).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/__tests__/defaultConnectors.test.ts

@@ -67,11 +67,14 @@ describe("defaultConnectors", () => {
       const customBaseUrl = "https://custom-api.example.com";
       await getDefaultConnectors(customBaseUrl);
 
-      expect(mockConnectorDector).toHaveBeenCalledWith({
-        id: "wallet1",
-        name: "Wallet 1",
-        icon: "https://custom-api.example.com/icon1.png",
-      });
+      expect(mockConnectorDector).toHaveBeenCalledWith(
+        expect.objectContaining({
+          id: "wallet1",
+          name: "Wallet 1",
+          icon: "https://custom-api.example.com/icon1.png",
+        }),
+        "tomo",
+      );
     });
 
     it("should return cached connectors on second call", async () => {