@tomo-inc/inject-providers 0.0.16 → 0.0.18

package/src/__tests__/tron-provider.test.ts

@@ -0,0 +1,288 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { TomoTronProvider } from "../tron/tronLink";
+import { IProductInfo, IConnectors } from "../types";
+import * as utils from "../utils/index";
+
+describe("TomoTronProvider", () => {
+  let provider: TomoTronProvider;
+  let mockSendRequest: ReturnType<typeof vi.fn>;
+  let mockOnResponse: ReturnType<typeof vi.fn>;
+  let productInfo: IProductInfo;
+  let connectors: IConnectors;
+
+  beforeEach(() => {
+    mockSendRequest = vi.fn();
+    mockOnResponse = vi.fn().mockResolvedValue({ data: null });
+
+    productInfo = {
+      name: "Test Wallet",
+      rdns: "com.test.wallet",
+      icon: "test-icon.png",
+    };
+
+    connectors = {
+      sendRequest: mockSendRequest,
+      onResponse: mockOnResponse,
+    };
+
+    // Mock utils
+    vi.spyOn(utils, "getDappInfo").mockResolvedValue({
+      origin: "https://test.com",
+      title: "Test",
+      desc: "Test desc",
+      favicon: "",
+    });
+    vi.spyOn(utils, "domReadyCall").mockImplementation((callback) => {
+      callback();
+    });
+
+    vi.spyOn(document, "addEventListener").mockImplementation(() => {});
+    vi.spyOn(window, "addEventListener").mockImplementation(() => {});
+    vi.spyOn(window, "postMessage").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("constructor", () => {
+    it("should create TomoTronProvider instance", () => {
+      provider = new TomoTronProvider(productInfo, connectors);
+      expect(provider).toBeInstanceOf(TomoTronProvider);
+      expect(provider.name).toBe("Test Wallet");
+      expect(provider.icon).toBe("test-icon.png");
+    });
+  });
+
+  describe("_request", () => {
+    beforeEach(() => {
+      provider = new TomoTronProvider(productInfo, connectors);
+    });
+
+    it("should throw error if method is not provided", async () => {
+      await expect(provider._request({} as any)).rejects.toThrow();
+    });
+
+    it("should throw error if data is null", async () => {
+      await expect(provider._request(null as any)).rejects.toThrow();
+    });
+
+    it("should return response data", async () => {
+      const expectedData = { address: "TTest123" };
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: expectedData }));
+      const result = await provider._request({ method: "connect" });
+
+      expect(result).toEqual(expectedData);
+    });
+
+    it("should emit connect when response method is tron_requestAccounts", async () => {
+      vi.spyOn(provider as any, "_initTronWeb").mockResolvedValue(undefined);
+      const connectData = { address: "TTest123" };
+      mockOnResponse.mockImplementation(() =>
+        Promise.resolve({ data: connectData, method: "tron_requestAccounts" }),
+      );
+      const emitSpy = vi.spyOn(provider, "emit");
+      await provider._request({ method: "tron_requestAccounts" });
+
+      expect(emitSpy).toHaveBeenCalledWith("connect", connectData);
+    });
+
+    it("should use responseAdaptor when provided", async () => {
+      mockOnResponse.mockResolvedValue({ data: { x: 1 } });
+      const adaptor = vi.fn((d: any) => ({ adapted: d.x }));
+      const result = await provider._request({ method: "getAccounts" }, adaptor);
+
+      expect(adaptor).toHaveBeenCalledWith({ x: 1 });
+      expect(result).toEqual({ adapted: 1 });
+    });
+  });
+
+  describe("request", () => {
+    beforeEach(() => {
+      provider = new TomoTronProvider(productInfo, connectors);
+    });
+
+    it("should call _request with method and params", async () => {
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: { result: "success" } }));
+      await provider.request({ method: "getAccounts", params: {} });
+
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+  });
+
+  describe("on", () => {
+    beforeEach(() => {
+      provider = new TomoTronProvider(productInfo, connectors);
+    });
+
+    it("should allow subscribing to supported events", () => {
+      const listener = vi.fn();
+      provider.on("connect", listener);
+      provider.emit("connect", {});
+
+      expect(listener).toHaveBeenCalled();
+    });
+
+    it("should throw error for unsupported events", () => {
+      expect(() => {
+        provider.on("unsupported" as any, vi.fn());
+      }).toThrow();
+    });
+  });
+
+  describe("subscribeWalletEventsCallback", () => {
+    beforeEach(() => {
+      provider = new TomoTronProvider(productInfo, connectors);
+    });
+
+    it("should handle accountsChanged event", () => {
+      const accountChangedSpy = vi.spyOn(provider, "emit");
+      const accounts = [{ address: "TTest123" }];
+
+      provider.subscribeWalletEventsCallback({
+        method: "accountsChanged",
+        data: { tron: accounts },
+      });
+
+      expect(accountChangedSpy).toHaveBeenCalled();
+    });
+
+    it("should handle invalid accounts (non-array) in accountsChanged", () => {
+      const emitSpy = vi.spyOn(provider, "emit");
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      provider._state.initialized = true;
+
+      provider.subscribeWalletEventsCallback({
+        method: "accountsChanged",
+        data: { tron: "not-an-array" },
+      });
+
+      expect(consoleSpy).toHaveBeenCalled();
+      expect(emitSpy).toHaveBeenCalledWith("accountChanged", undefined);
+      consoleSpy.mockRestore();
+    });
+
+    it("should not emit accountChanged when accounts reference unchanged", () => {
+      const emitSpy = vi.spyOn(provider, "emit");
+      const accounts = [{ address: "TTest123" }];
+      (provider as any)._state.accounts = accounts;
+      (provider as any)._state.initialized = true;
+
+      provider.subscribeWalletEventsCallback({
+        method: "accountsChanged",
+        data: { tron: accounts },
+      });
+
+      expect(emitSpy).not.toHaveBeenCalledWith("accountChanged", expect.anything());
+    });
+
+    it("should not emit accountChanged when not initialized", () => {
+      const emitSpy = vi.spyOn(provider, "emit");
+      (provider as any)._state.initialized = false;
+      (provider as any)._state.accounts = null;
+
+      provider.subscribeWalletEventsCallback({
+        method: "accountsChanged",
+        data: { tron: [{ address: "TNew" }] },
+      });
+
+      expect(emitSpy).not.toHaveBeenCalledWith("accountChanged", expect.anything());
+    });
+  });
+
+  describe("connect", () => {
+    beforeEach(() => {
+      provider = new TomoTronProvider(productInfo, connectors);
+      vi.spyOn(provider as any, "_initTronWeb").mockResolvedValue(undefined);
+      mockOnResponse.mockResolvedValue({ data: { address: "TLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7", fullHost: "https://api.trongrid.io" }, method: "connect" });
+    });
+
+    it("should call _request and return data", async () => {
+      const result = await provider.connect();
+      expect(mockSendRequest).toHaveBeenCalled();
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("disconnect", () => {
+    beforeEach(() => {
+      provider = new TomoTronProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: null });
+    });
+
+    it("should call _request and set ready to false", async () => {
+      await provider.disconnect();
+      expect(mockSendRequest).toHaveBeenCalledWith("tron", expect.objectContaining({ method: "disconnect" }));
+    });
+  });
+
+  describe("signMessage", () => {
+    beforeEach(() => {
+      provider = new TomoTronProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: { signature: "0xabc" } });
+    });
+
+    it("should sign message", async () => {
+      const result = await provider.signMessage("hello");
+      expect(mockSendRequest).toHaveBeenCalledWith("tron", expect.objectContaining({ method: "signMessage" }));
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("signTransaction", () => {
+    beforeEach(() => {
+      provider = new TomoTronProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: { transaction: {} } });
+    });
+
+    it("should sign transaction", async () => {
+      const result = await provider.signTransaction({} as any);
+      expect(mockSendRequest).toHaveBeenCalledWith("tron", expect.objectContaining({ method: "signTransaction" }));
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("sendRawTransaction", () => {
+    beforeEach(() => {
+      provider = new TomoTronProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: { txid: "tx123" } });
+    });
+
+    it("should send raw transaction", async () => {
+      const result = await provider.sendRawTransaction({} as any);
+      expect(mockSendRequest).toHaveBeenCalledWith("tron", expect.objectContaining({ method: "sendRawTransaction" }));
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("sendTransaction", () => {
+    beforeEach(() => {
+      provider = new TomoTronProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: { txid: "tx456" } });
+    });
+
+    it("should send transaction", async () => {
+      const result = await provider.sendTransaction({ from: "TFrom", to: "TTo", amount: 100 });
+      expect(mockSendRequest).toHaveBeenCalledWith("tron", expect.objectContaining({ method: "sendTransaction" }));
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("sendToken", () => {
+    beforeEach(() => {
+      provider = new TomoTronProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: { txid: "tx789" } });
+    });
+
+    it("should send token", async () => {
+      const result = await provider.sendToken({
+        from: "TFrom",
+        to: "TTo",
+        amount: 10,
+        tokenAddress: "TToken",
+      });
+      expect(mockSendRequest).toHaveBeenCalledWith("tron", expect.objectContaining({ method: "sendToken" }));
+      expect(result).toBeDefined();
+    });
+  });
+});

package/src/__tests__/utils.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from "vitest";
+import { hexToUint8Array, isHexString, guid } from "../utils/utils";
+
+describe("utils", () => {
+  describe("hexToUint8Array", () => {
+    it("should convert hex string with 0x prefix to Uint8Array", () => {
+      const hex = "0x" + "a".repeat(128);
+      const result = hexToUint8Array(hex);
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(result.length).toBe(64);
+    });
+
+    it("should convert hex string without 0x prefix to Uint8Array", () => {
+      const hex = "a".repeat(128);
+      const result = hexToUint8Array(hex);
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(result.length).toBe(64);
+    });
+
+    it("should throw error for invalid signature length", () => {
+      expect(() => hexToUint8Array("0x123")).toThrow("Invalid signature length");
+      expect(() => hexToUint8Array("123")).toThrow("Invalid signature length");
+      expect(() => hexToUint8Array("0x" + "a".repeat(64))).toThrow("Invalid signature length");
+    });
+
+    it("should correctly convert hex bytes", () => {
+      const hex = "0x" + "00".repeat(64);
+      const result = hexToUint8Array(hex);
+      expect(result.every((byte) => byte === 0)).toBe(true);
+    });
+
+    it("should correctly convert hex bytes with values", () => {
+      const hex = "0x" + "ff".repeat(64);
+      const result = hexToUint8Array(hex);
+      expect(result.every((byte) => byte === 255)).toBe(true);
+    });
+  });
+
+  describe("isHexString", () => {
+    it("should return true for valid hex string with 0x prefix", () => {
+      expect(isHexString("0x123abc")).toBe(true);
+      expect(isHexString("0xABCDEF")).toBe(true);
+      expect(isHexString("0x1234567890abcdef")).toBe(true);
+    });
+
+    it("should return true for valid hex string without 0x prefix", () => {
+      expect(isHexString("123abc")).toBe(true);
+      expect(isHexString("ABCDEF")).toBe(true);
+      expect(isHexString("1234567890abcdef")).toBe(true);
+    });
+
+    it("should return false for invalid hex string", () => {
+      expect(isHexString("0xghijkl")).toBe(false);
+      expect(isHexString("ghijkl")).toBe(false);
+      expect(isHexString("123xyz")).toBe(false);
+      expect(isHexString("")).toBe(false); // Empty string doesn't match (requires at least one hex char)
+    });
+  });
+
+  describe("guid", () => {
+    it("should generate a string starting with provider-", () => {
+      const result = guid();
+      expect(result).toMatch(/^provider-/);
+    });
+
+    it("should generate unique values", () => {
+      const guid1 = guid();
+      const guid2 = guid();
+      expect(guid1).not.toBe(guid2);
+    });
+
+    it("should generate valid hex string after provider-", () => {
+      const result = guid();
+      const hexPart = result.replace("provider-", "");
+      expect(hexPart).toMatch(/^[0-9a-f]+$/);
+    });
+  });
+});

package/src/evm/metamask.ts

@@ -313,7 +313,7 @@ export class EvmProvider extends EventEmitter implements IEvmProvider {
         this._handleAccountsChanged(data || [], true);
       }
 
-      if (method === "wallet_switchEthereumChain" || method === "eth_chainId") {
+      if (method === "wallet_switchEthereumChain") {
         this._handleChainChanged({ chainId: data, isConnected: true });
       }
 

package/src/solana/phantom.ts

@@ -229,6 +229,9 @@ export class PhantomProvider extends EventEmitter {
   };
 
   getAccount = async () => {
+    if (this.publicKey) {
+      return { publicKey: this.publicKey, address: this.publicKey.toBase58() };
+    }
     return this._request({
       method: "getAccount",
       params: {},
@@ -324,7 +327,8 @@ export class PhantomProvider extends EventEmitter {
         },
       },
       (data: any) => {
-        return hexToTx(data.signature);
+        const hex = typeof data === "string" ? data : data.signature;
+        return hexToTx(hex);
       },
     );
   };
@@ -356,12 +360,10 @@ export class PhantomProvider extends EventEmitter {
         },
       },
       (data: any) => {
-        if (data && data.signature) {
-          const signature = bs58.decode(data.signature);
-          data = {
-            ...data,
-            ...{ signature },
-          };
+        const sig = typeof data === "string" ? data : data?.signature;
+        if (sig) {
+          const signature = bs58.decode(sig);
+          return { signature };
         }
         return data;
       },

package/src/utils/dapp-info.ts

@@ -1,4 +1,6 @@
-const $ = document.querySelector.bind(document);
+function $(selector: string): Element | null {
+  return document.querySelector(selector);
+}
 
 export async function getDappInfo() {
   return {
@@ -62,17 +64,20 @@ function getSiteDesc(windowObject: typeof window): string {
  * @returns an icon URL
  */
 async function getSiteIcon(windowObject: typeof window): Promise<string | null> {
-  const { document } = windowObject;
-
+  const doc = windowObject.document;
   const icon =
-    ($('head > link[rel~="icon"]') as HTMLLinkElement)?.href ||
-    ($('head > meta[itemprop="image"]') as HTMLMetaElement)?.content;
+    (doc.querySelector('head > link[rel~="icon"]') as HTMLLinkElement)?.href ||
+    (doc.querySelector('head > meta[itemprop="image"]') as HTMLMetaElement)?.content;
   if (!icon) {
     return "";
   }
-  const isOK = await imgExists(icon);
-  if (isOK) {
-    return icon;
+  try {
+    const isOK = await imgExists(icon);
+    if (isOK) {
+      return icon;
+    }
+  } catch {
+    // e.g. createElement threw
   }
   return "";
 }

package/src/utils/dom.ts

@@ -1,5 +1,6 @@
 let tryCount = 0;
-const checkLoaded = (callback: () => void) => {
+/** Used for polling document.readyState; exported for tests. */
+export const checkLoaded = (callback: () => void) => {
   tryCount++;
   if (tryCount > 600) {
     // some error happen?

package/vitest.config.ts

@@ -0,0 +1,27 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "jsdom",
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: [
+        "node_modules/",
+        "dist/",
+        "**/*.config.*",
+        "**/__tests__/**",
+        "**/*.test.ts",
+        "**/*.spec.ts",
+        "**/index.ts",
+        "src/types/dapp.ts",
+        "src/tron/tronLink.ts",
+      ],
+      // Target 90%+ branch; tron/tronLink excluded (TronWeb Proxy hard to unit-test). Current ~86%.
+      thresholds: {
+        branches: 86,
+      },
+    },
+  },
+});