@tomo-inc/inject-providers 0.0.15 → 0.0.17

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

@@ -0,0 +1,523 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { BitcoinProvider } from "../btc";
+import { IProductInfo, IConnectors } from "../types";
+import * as utils from "../utils/index";
+
+describe("BitcoinProvider", () => {
+  let provider: BitcoinProvider;
+  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();
+    });
+
+    // Mock document methods
+    vi.spyOn(document, "addEventListener").mockImplementation(() => {});
+    vi.spyOn(window, "addEventListener").mockImplementation(() => {});
+
+    // Mock setTimeout to prevent keepAlive from running
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  describe("constructor", () => {
+    it("should create BitcoinProvider instance", () => {
+      provider = new BitcoinProvider(productInfo, connectors);
+      expect(provider).toBeInstanceOf(BitcoinProvider);
+      expect(provider.name).toBe("Test Wallet");
+      expect(provider.rdns).toBe("com.test.wallet");
+    });
+
+    it("should initialize with default values", () => {
+      provider = new BitcoinProvider(productInfo, connectors);
+      expect(provider._selectedAddress).toBeNull();
+      expect(provider._isConnected).toBe(false);
+      expect(provider._initialized).toBe(false);
+      expect(provider.chainId).toBe("BITCOIN_MAINNET");
+    });
+
+    it("should call _request on visibilitychange when visible", async () => {
+      let visibilityHandler: (() => void) | null = null;
+      vi.mocked(document.addEventListener).mockImplementation((event: string, handler: any) => {
+        if (event === "visibilitychange") visibilityHandler = handler;
+      });
+      provider = new BitcoinProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({});
+      Object.defineProperty(document, "visibilityState", {
+        value: "visible",
+        writable: true,
+        configurable: true,
+      });
+      if (visibilityHandler) await visibilityHandler();
+      expect(mockSendRequest).toHaveBeenCalledWith(
+        "bitcoin",
+        expect.objectContaining({ method: "wallet_sendDomainMetadata" }),
+      );
+    });
+
+    it("should handle window message subscribeWalletEvents", () => {
+      let messageHandler: ((e: MessageEvent) => void) | null = null;
+      vi.mocked(window.addEventListener).mockImplementation((event: string, handler: any) => {
+        if (event === "message") messageHandler = handler;
+      });
+      provider = new BitcoinProvider(productInfo, connectors);
+      (provider as any)._state.initialized = true;
+      const emitSpy = vi.spyOn(provider, "emit");
+      if (messageHandler) {
+        messageHandler({
+          data: {
+            type: "subscribeWalletEvents",
+            method: "accountsChanged",
+            data: { bitcoin: [{ address: "bc1xxx" }] },
+          },
+        } as MessageEvent);
+      }
+      expect(emitSpy).toHaveBeenCalledWith("accountsChanged", ["bc1xxx"]);
+    });
+  });
+
+  describe("request", () => {
+    beforeEach(() => {
+      provider = new BitcoinProvider(productInfo, connectors);
+    });
+
+    it("should throw error if method is not provided", async () => {
+      await expect(provider.request({ method: "", params: {} })).rejects.toThrow();
+    });
+
+    it("should call sendRequest with correct parameters", async () => {
+      mockOnResponse.mockImplementation(({ method }) => {
+        return Promise.resolve({ data: ["0x123"] });
+      });
+      await provider.request({ method: "getAccounts", params: {} });
+
+      expect(mockSendRequest).toHaveBeenCalled();
+      expect(mockOnResponse).toHaveBeenCalledWith({ method: "getAccounts" });
+    });
+
+    it("should return response data", async () => {
+      const expectedData = ["0x123"];
+      mockOnResponse.mockImplementation(({ method }) => {
+        return Promise.resolve({ data: expectedData });
+      });
+      const result = await provider.request({ method: "getAccounts", params: {} });
+
+      expect(result).toEqual(expectedData);
+    });
+  });
+
+  describe("connect", () => {
+    beforeEach(() => {
+      provider = new BitcoinProvider(productInfo, connectors);
+    });
+
+    it("should call request with connect method", async () => {
+      mockOnResponse.mockImplementation(({ method }) => {
+        return Promise.resolve({ data: { address: "0x123" } });
+      });
+      await provider.connect();
+
+      expect(mockSendRequest).toHaveBeenCalled();
+      expect(mockOnResponse).toHaveBeenCalledWith({ method: "connect" });
+    });
+  });
+
+  describe("disconnect", () => {
+    beforeEach(() => {
+      provider = new BitcoinProvider(productInfo, connectors);
+    });
+
+    it("should call request with disconnect method", async () => {
+      mockOnResponse.mockImplementation(({ method }) => {
+        return Promise.resolve({ data: { disconnected: true } });
+      });
+      await provider.disconnect();
+
+      expect(mockSendRequest).toHaveBeenCalled();
+      expect(mockOnResponse).toHaveBeenCalledWith({ method: "disconnect" });
+    });
+  });
+
+  describe("requestAccounts", () => {
+    beforeEach(() => {
+      provider = new BitcoinProvider(productInfo, connectors);
+    });
+
+    it("should return accounts array", async () => {
+      const accounts = ["0x123", "0x456"];
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: accounts }));
+      const result = await provider.requestAccounts();
+
+      expect(result).toEqual(accounts);
+    });
+  });
+
+  describe("getAccounts", () => {
+    beforeEach(() => {
+      provider = new BitcoinProvider(productInfo, connectors);
+    });
+
+    it("should return accounts array", async () => {
+      const accounts = ["0x123"];
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: accounts }));
+      const result = await provider.getAccounts();
+
+      expect(result).toEqual(accounts);
+    });
+  });
+
+  describe("signMessage", () => {
+    beforeEach(() => {
+      provider = new BitcoinProvider(productInfo, connectors);
+    });
+
+    it("should sign message with default type", async () => {
+      const signature = "0xsignature";
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: signature }));
+      const result = await provider.signMessage("test message");
+
+      expect(result).toBe(signature);
+    });
+
+    it("should sign message with specified type", async () => {
+      const signature = "0xsignature";
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: signature }));
+      const result = await provider.signMessage("test message", "ecdsa");
+
+      expect(result).toBe(signature);
+    });
+  });
+
+  describe("getBalance", () => {
+    beforeEach(() => {
+      provider = new BitcoinProvider(productInfo, connectors);
+    });
+
+    it("should return balance", async () => {
+      const balance = { confirmed: 1000, unconfirmed: 100, total: 1100 };
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: balance }));
+      const result = await provider.getBalance();
+
+      expect(result).toEqual(balance);
+    });
+  });
+
+  describe("_request with adapter", () => {
+    beforeEach(() => {
+      provider = new BitcoinProvider(productInfo, connectors);
+    });
+
+    it("should use adapter when provided", async () => {
+      mockOnResponse.mockResolvedValue({ data: { confirmed: 100 } });
+      const adapter = vi.fn((d: any) => ({ wrapped: d }));
+      const result = await (provider as any)._request({ method: "getBalance" }, adapter);
+      expect(adapter).toHaveBeenCalledWith({ confirmed: 100 });
+      expect(result).toEqual({ wrapped: { confirmed: 100 } });
+    });
+  });
+
+  describe("_request connect and wallet_switchEthereumChain branches", () => {
+    beforeEach(() => {
+      provider = new BitcoinProvider(productInfo, connectors);
+    });
+
+    it("should call _handleAccountsChanged when method is connect and data has address", async () => {
+      mockOnResponse.mockResolvedValue({ data: { address: "bc1xxx" } });
+      await (provider as any)._request({ method: "connect" });
+      expect(provider._selectedAddress).toBe("bc1xxx");
+    });
+
+    it("should call _handleChainChanged when method is wallet_switchEthereumChain", async () => {
+      mockOnResponse.mockResolvedValue({ data: "0x2" });
+      const emitSpy = vi.spyOn(provider, "emit");
+      await (provider as any)._request({ method: "wallet_switchEthereumChain" });
+      expect(emitSpy).toHaveBeenCalledWith("chainChanged", "0x2");
+    });
+
+    it("should handle connect with no address in response", async () => {
+      mockOnResponse.mockResolvedValue({ data: {} });
+      const result = await (provider as any)._request({ method: "connect" });
+      expect(result).toEqual({});
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+
+    it("should return data when response is null (res || {} branch)", async () => {
+      mockOnResponse.mockResolvedValue(null);
+      const result = await (provider as any)._request({ method: "getBalance" });
+      expect(result).toBeUndefined();
+    });
+
+    it("should call _handleAccountsChanged when method is getAccounts", async () => {
+      mockOnResponse.mockResolvedValue({ data: ["addr1", "addr2"] });
+      await (provider as any)._request({ method: "getAccounts" });
+      expect((provider as any)._state.accounts).toEqual(["addr1", "addr2"]);
+    });
+  });
+
+  describe("subscribeWalletEventsCallback", () => {
+    beforeEach(() => {
+      provider = new BitcoinProvider(productInfo, connectors);
+      provider._state.initialized = true;
+    });
+
+    it("should handle accountsChanged event", () => {
+      const accountsChangedSpy = vi.spyOn(provider, "emit");
+      // ChainTypes.BITCOIN is "bitcoin" from wallet-utils
+      const data = {
+        bitcoin: [{ address: "0x123" }],
+      };
+
+      provider.subscribeWalletEventsCallback({
+        method: "accountsChanged",
+        data,
+      });
+
+      expect(accountsChangedSpy).toHaveBeenCalledWith("accountsChanged", ["0x123"]);
+    });
+
+    it("should handle chainChanged event", () => {
+      const chainChangedSpy = vi.spyOn(provider, "emit");
+      const data = {
+        chainId: "0x1",
+        type: "bitcoin:mainnet",
+      };
+
+      provider.subscribeWalletEventsCallback({
+        method: "chainChanged",
+        data,
+      });
+
+      expect(chainChangedSpy).toHaveBeenCalledWith("chainChanged", "0x1");
+    });
+
+    it("should not emit chainChanged when type does not match chain prefix", () => {
+      const chainChangedSpy = vi.spyOn(provider, "emit");
+      provider.subscribeWalletEventsCallback({
+        method: "chainChanged",
+        data: { chainId: "0x2", type: "eth:mainnet" },
+      });
+      expect(chainChangedSpy).not.toHaveBeenCalledWith("chainChanged", expect.anything());
+    });
+
+    it("should not emit chainChanged when chainId is same as current", () => {
+      const chainChangedSpy = vi.spyOn(provider, "emit");
+      provider.chainId = "0x1";
+      provider.subscribeWalletEventsCallback({
+        method: "chainChanged",
+        data: { chainId: "0x1", type: "bitcoin:mainnet" },
+      });
+      expect(chainChangedSpy).not.toHaveBeenCalled();
+    });
+
+    it("should not emit chainChanged when not initialized", () => {
+      (provider as any)._state.initialized = false;
+      const chainChangedSpy = vi.spyOn(provider, "emit");
+      provider.subscribeWalletEventsCallback({
+        method: "chainChanged",
+        data: { chainId: "0x2", type: "bitcoin:mainnet" },
+      });
+      expect(chainChangedSpy).not.toHaveBeenCalled();
+    });
+
+    it("should not emit chainChanged when chainId is missing or invalid", () => {
+      const chainChangedSpy = vi.spyOn(provider, "emit");
+      provider.subscribeWalletEventsCallback({
+        method: "chainChanged",
+        data: { type: "bitcoin:mainnet" },
+      });
+      expect(chainChangedSpy).not.toHaveBeenCalled();
+      provider.subscribeWalletEventsCallback({
+        method: "chainChanged",
+        data: { chainId: 123, type: "bitcoin:mainnet" },
+      });
+      expect(chainChangedSpy).not.toHaveBeenCalled();
+      provider.subscribeWalletEventsCallback({
+        method: "chainChanged",
+        data: { chainId: "abc", type: "bitcoin:mainnet" },
+      });
+      expect(chainChangedSpy).not.toHaveBeenCalled();
+    });
+
+    it("should handle accountsChanged with invalid (non-array) accounts from getAccounts response", async () => {
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      mockOnResponse.mockResolvedValue({ data: "not-an-array" });
+      await provider.getAccounts();
+      expect(provider._state.accounts).toEqual([]);
+      expect(consoleSpy).toHaveBeenCalledWith("BTC: Received invalid accounts parameter.", "not-an-array");
+      consoleSpy.mockRestore();
+    });
+
+    it("should handle chainChanged when type does not start with bitcoin:", () => {
+      const emitSpy = vi.spyOn(provider, "emit");
+      provider.subscribeWalletEventsCallback({
+        method: "chainChanged",
+        data: { chainId: "0x1", type: "evm:1" },
+      });
+      expect(provider.chainId).toBe("BITCOIN_MAINNET");
+      expect(emitSpy).not.toHaveBeenCalledWith("chainChanged", expect.anything());
+    });
+
+    it("should not emit chainChanged when chainId is invalid (no 0x prefix)", () => {
+      const emitSpy = vi.spyOn(provider, "emit");
+      provider.subscribeWalletEventsCallback({
+        method: "chainChanged",
+        data: { chainId: "1", type: "bitcoin:mainnet" },
+      });
+      expect(provider.chainId).toBe("BITCOIN_MAINNET");
+      expect(emitSpy).not.toHaveBeenCalledWith("chainChanged", expect.anything());
+    });
+
+    it("should not emit chainChanged when chainId equals current chainId", () => {
+      provider.chainId = "0x1";
+      const emitSpy = vi.spyOn(provider, "emit");
+      provider.subscribeWalletEventsCallback({
+        method: "chainChanged",
+        data: { chainId: "0x1", type: "bitcoin:mainnet" },
+      });
+      expect(emitSpy).not.toHaveBeenCalledWith("chainChanged", expect.anything());
+    });
+
+    it("should not emit chainChanged when not initialized", () => {
+      provider._state.initialized = false;
+      const emitSpy = vi.spyOn(provider, "emit");
+      provider.subscribeWalletEventsCallback({
+        method: "chainChanged",
+        data: { chainId: "0x2", type: "bitcoin:mainnet" },
+      });
+      expect(provider.chainId).toBe("BITCOIN_MAINNET");
+      expect(emitSpy).not.toHaveBeenCalledWith("chainChanged", expect.anything());
+    });
+  });
+
+  describe("_request branches", () => {
+    beforeEach(() => {
+      provider = new BitcoinProvider(productInfo, connectors);
+    });
+
+    it("should call _handleChainChanged when method is wallet_switchEthereumChain", async () => {
+      const emitSpy = vi.spyOn(provider, "emit");
+      mockOnResponse.mockImplementation(({ method }) => {
+        if (method === "wallet_switchEthereumChain") {
+          return Promise.resolve({ data: "0x2" });
+        }
+        return Promise.resolve({ data: null });
+      });
+      await provider.request({ method: "wallet_switchEthereumChain", params: { chainId: "0x2" } });
+      expect(provider.chainId).toBe("0x2");
+      expect(emitSpy).toHaveBeenCalledWith("chainChanged", "0x2");
+    });
+
+    it("should call _handleAccountsChanged when connect returns data.address", async () => {
+      mockOnResponse.mockImplementation(({ method }) => {
+        if (method === "connect") {
+          return Promise.resolve({ data: { address: "bc1new" } });
+        }
+        return Promise.resolve({ data: null });
+      });
+      const emitSpy = vi.spyOn(provider, "emit");
+      provider._state.initialized = true;
+      await provider.connect();
+      expect(provider._selectedAddress).toBe("bc1new");
+      expect(emitSpy).toHaveBeenCalledWith("accountsChanged", ["bc1new"]);
+    });
+
+    it("should use adapter when provided", async () => {
+      const adapted = { adapted: true };
+      mockOnResponse.mockResolvedValue({ data: { raw: 1 } });
+      const result = await (provider as any)._request(
+        { method: "getBalance", params: {} },
+        (data: any) => ({ ...data, adapted: true }),
+      );
+      expect(result).toEqual({ raw: 1, adapted: true });
+    });
+  });
+
+  describe("public API methods", () => {
+    beforeEach(() => {
+      provider = new BitcoinProvider(productInfo, connectors);
+      mockOnResponse.mockImplementation(({ method }) => Promise.resolve({ data: `res-${method}` }));
+    });
+
+    it("getPublicKey", async () => {
+      const r = await provider.getPublicKey();
+      expect(r).toBe("res-getPublicKey");
+    });
+    it("getTransactionStatus", async () => {
+      const r = await provider.getTransactionStatus({ txId: "abc" });
+      expect(r).toBe("res-getTransactionStatus");
+    });
+    it("getNetwork", async () => {
+      const r = await provider.getNetwork();
+      expect(r).toBe("res-getNetwork");
+    });
+    it("switchNetwork", async () => {
+      const r = await provider.switchNetwork("mainnet");
+      expect(mockSendRequest).toHaveBeenCalledWith("bitcoin", expect.objectContaining({ method: "switchNetwork", params: { network: "mainnet" } }));
+    });
+    it("getChain", async () => {
+      const r = await provider.getChain();
+      expect(r).toBe("res-getChain");
+    });
+    it("switchChain", async () => {
+      const r = await provider.switchChain("BITCOIN_MAINNET");
+      expect(r).toBe("res-switchChain");
+    });
+    it("signPsbt", async () => {
+      const r = await provider.signPsbt("hex");
+      expect(r).toBe("res-signPsbt");
+    });
+    it("signPsbts", async () => {
+      const r = await provider.signPsbts(["a", "b"]);
+      expect(r).toBe("res-signPsbts");
+    });
+    it("pushPsbt", async () => {
+      const r = await provider.pushPsbt("hex");
+      expect(r).toBe("res-pushPsbt");
+    });
+    it("sendBitcoin", async () => {
+      const r = await provider.sendBitcoin("addr", 1000, { feeRate: 5 });
+      expect(r).toBe("res-sendBitcoin");
+    });
+    it("signTx", async () => {
+      const r = await provider.signTx("raw");
+      expect(r).toBe("res-signTx");
+    });
+    it("pushTx", async () => {
+      const r = await provider.pushTx("raw");
+      expect(r).toBe("res-pushTx");
+    });
+    it("sendTransaction", async () => {
+      const r = await provider.sendTransaction({ from: "a", to: "b" });
+      expect(r).toBe("res-sendTransaction");
+    });
+  });
+});