@tomo-inc/inject-providers 0.0.16 → 0.0.18

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

@@ -0,0 +1,288 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { DogecoinProvider } from "../dogecoin/dogecoin";
+import { IProductInfo, IConnectors } from "../types";
+import * as utils from "../utils/index";
+
+describe("DogecoinProvider", () => {
+  let provider: DogecoinProvider;
+  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.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  describe("constructor", () => {
+    it("should create DogecoinProvider instance", () => {
+      provider = new DogecoinProvider(productInfo, connectors);
+      expect(provider).toBeInstanceOf(DogecoinProvider);
+      expect(provider.name).toBe("Test Wallet");
+      expect(provider.rdns).toBe("com.test.wallet");
+    });
+
+    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 DogecoinProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({});
+      Object.defineProperty(document, "visibilityState", {
+        value: "visible",
+        writable: true,
+        configurable: true,
+      });
+      if (visibilityHandler) await visibilityHandler();
+      expect(mockSendRequest).toHaveBeenCalledWith(
+        "dogecoin",
+        expect.objectContaining({ method: "wallet_sendDomainMetadata" }),
+      );
+    });
+  });
+
+  describe("request", () => {
+    beforeEach(() => {
+      provider = new DogecoinProvider(productInfo, connectors);
+    });
+
+    it("should throw error if method is not provided", async () => {
+      await expect(provider.request({ method: "", params: {} })).rejects.toThrow();
+    });
+
+    it("should return response data", async () => {
+      const expectedData = ["0x123"];
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: expectedData }));
+      const result = await provider.request({ method: "getAccounts", params: {} });
+
+      expect(result).toEqual(expectedData);
+    });
+  });
+
+  describe("_request with adapter", () => {
+    beforeEach(() => {
+      provider = new DogecoinProvider(productInfo, connectors);
+    });
+
+    it("should use adapter when provided", async () => {
+      mockOnResponse.mockResolvedValue({ data: { balance: 100 } });
+      const adapter = vi.fn((d: any) => ({ adapted: d }));
+      const result = await (provider as any)._request({ method: "getBalance" }, adapter);
+      expect(adapter).toHaveBeenCalledWith({ balance: 100 });
+      expect(result).toEqual({ adapted: { balance: 100 } });
+    });
+
+    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();
+    });
+  });
+
+  describe("connect", () => {
+    beforeEach(() => {
+      provider = new DogecoinProvider(productInfo, connectors);
+    });
+
+    it("should call request with connect method", async () => {
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: { address: "0x123" } }));
+      await provider.connect();
+
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+  });
+
+  describe("disconnect", () => {
+    beforeEach(() => {
+      provider = new DogecoinProvider(productInfo, connectors);
+    });
+
+    it("should call request with disconnect method", async () => {
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: { disconnected: true } }));
+      await provider.disconnect();
+
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+  });
+
+  describe("requestAccounts", () => {
+    beforeEach(() => {
+      provider = new DogecoinProvider(productInfo, connectors);
+    });
+
+    it("should return accounts array", async () => {
+      const accounts = ["0x123"];
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: accounts }));
+      const result = await provider.requestAccounts();
+
+      expect(result).toEqual(accounts);
+    });
+  });
+
+  describe("signMessage", () => {
+    beforeEach(() => {
+      provider = new DogecoinProvider(productInfo, connectors);
+    });
+
+    it("should sign message and return signed message", async () => {
+      const signedMessage = "signed-message";
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: { signedMessage } }));
+      const result = await provider.signMessage("test message");
+
+      expect(result).toBe(signedMessage);
+    });
+  });
+
+  describe("getBalance", () => {
+    beforeEach(() => {
+      provider = new DogecoinProvider(productInfo, connectors);
+    });
+
+    it("should return balance object", 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("sendDogecoin", () => {
+    beforeEach(() => {
+      provider = new DogecoinProvider(productInfo, connectors);
+    });
+
+    it("should send dogecoin with amount", async () => {
+      const txId = "0xtxid";
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: txId }));
+      const result = await provider.sendDogecoin("0xrecipient", 1000);
+
+      expect(result).toBe(txId);
+    });
+
+    it("should send dogecoin with options", async () => {
+      const txId = "0xtxid";
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: txId }));
+      const result = await provider.sendDogecoin("0xrecipient", 1000, { feeRate: 10 });
+
+      expect(result).toBe(txId);
+    });
+  });
+
+  describe("additional API methods", () => {
+    beforeEach(() => {
+      provider = new DogecoinProvider(productInfo, connectors);
+      mockOnResponse.mockImplementation(({ method }: { method: string }) =>
+        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: "tx1" });
+      expect(r).toBe("res-getTransactionStatus");
+    });
+    it("requestSignedMessage with type", async () => {
+      const r = await provider.requestSignedMessage({ message: "hi", type: "ecdsa" });
+      expect(r).toBe("res-requestSignedMessage");
+    });
+    it("requestDecryptedMessage", async () => {
+      const r = await provider.requestDecryptedMessage({ message: "enc" });
+      expect(r).toBe("res-requestDecryptedMessage");
+    });
+    it("requestPsbt", async () => {
+      const r = await provider.requestPsbt({ rawTx: "hex" });
+      expect(r).toBe("res-requestPsbt");
+    });
+    it("signPsbt", async () => {
+      const r = await provider.signPsbt("hex", { autoFinalized: true });
+      expect(r).toBe("res-signPsbt");
+    });
+    it("signPsbts", async () => {
+      const r = await provider.signPsbts(["a", "b"], {});
+      expect(r).toBe("res-signPsbts");
+    });
+    it("requestTransaction", async () => {
+      const r = await provider.requestTransaction({ recipientAddress: "addr", dogeAmount: 100 });
+      expect(r).toBe("res-requestTransaction");
+    });
+    it("send", async () => {
+      const r = await provider.send("addr", 1000, { feeRate: 5 });
+      expect(r).toBe("res-send");
+    });
+    it("getConnectionStatus", async () => {
+      const r = await provider.getConnectionStatus();
+      expect(r).toBe("res-getConnectionStatus");
+    });
+    it("getDRC20Balances", async () => {
+      const r = await provider.getDRC20Balances("addr", "ticker");
+      expect(r).toBe("res-getDRC20Balances");
+    });
+    it("getDRC20Balance", async () => {
+      const r = await provider.getDRC20Balance({ ticker: "t" });
+      expect(r).toBe("res-getDRC20Balance");
+    });
+    it("getTransferableDRC20", async () => {
+      const r = await provider.getTransferableDRC20({ ticker: "t" });
+      expect(r).toBe("res-getTransferableDRC20");
+    });
+    it("requestAvailableDRC20Transaction", async () => {
+      const r = await provider.requestAvailableDRC20Transaction({ ticker: "t", amount: 1 });
+      expect(r).toBe("res-requestAvailableDRC20Transaction");
+    });
+    it("requestInscriptionTransaction", async () => {
+      const r = await provider.requestInscriptionTransaction({
+        location: "loc",
+        recipientAddress: "addr",
+      });
+      expect(r).toBe("res-requestInscriptionTransaction");
+    });
+    it("getDunesBalance", async () => {
+      const r = await provider.getDunesBalance({ ticker: "t" });
+      expect(r).toBe("res-getDunesBalance");
+    });
+    it("requestDunesTransaction", async () => {
+      const r = await provider.requestDunesTransaction({
+        ticker: "t",
+        amount: 1,
+        recipientAddress: "addr",
+      });
+      expect(r).toBe("res-requestDunesTransaction");
+    });
+  });
+});

package/src/__tests__/dom.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { domReadyCall, checkLoaded } from "../utils/dom";
+
+describe("dom", () => {
+  let originalReadyState: DocumentReadyState;
+  let originalAddEventListener: typeof document.addEventListener;
+  let originalRemoveEventListener: typeof document.removeEventListener;
+
+  beforeEach(() => {
+    originalReadyState = document.readyState;
+    originalAddEventListener = document.addEventListener;
+    originalRemoveEventListener = document.removeEventListener;
+  });
+
+  afterEach(() => {
+    Object.defineProperty(document, "readyState", {
+      value: originalReadyState,
+      writable: true,
+      configurable: true,
+    });
+    document.addEventListener = originalAddEventListener;
+    document.removeEventListener = originalRemoveEventListener;
+  });
+
+  describe("domReadyCall", () => {
+    it("should call callback immediately if document is already complete", () => {
+      Object.defineProperty(document, "readyState", {
+        value: "complete",
+        writable: true,
+        configurable: true,
+      });
+
+      const callback = vi.fn();
+      domReadyCall(callback);
+
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    it("should add event listener if document is not complete", () => {
+      Object.defineProperty(document, "readyState", {
+        value: "loading",
+        writable: true,
+        configurable: true,
+      });
+
+      const callback = vi.fn();
+      const addEventListenerSpy = vi.fn();
+      document.addEventListener = addEventListenerSpy;
+
+      domReadyCall(callback);
+
+      expect(addEventListenerSpy).toHaveBeenCalledWith("DOMContentLoaded", expect.any(Function));
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    it("should call callback and remove listener when DOMContentLoaded fires", () => {
+      Object.defineProperty(document, "readyState", {
+        value: "loading",
+        writable: true,
+        configurable: true,
+      });
+
+      const callback = vi.fn();
+      let eventHandler: ((e: Event) => void) | null = null;
+      const removeEventListenerSpy = vi.fn();
+
+      document.addEventListener = vi.fn((event: string, handler: EventListener) => {
+        if (event === "DOMContentLoaded") {
+          eventHandler = handler as (e: Event) => void;
+        }
+      });
+      document.removeEventListener = removeEventListenerSpy;
+
+      domReadyCall(callback);
+
+      // Simulate DOMContentLoaded event
+      if (eventHandler) {
+        eventHandler(new Event("DOMContentLoaded"));
+      }
+
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(removeEventListenerSpy).toHaveBeenCalledWith("DOMContentLoaded", eventHandler);
+    });
+
+    it("checkLoaded should call callback when document.readyState is complete", () => {
+      Object.defineProperty(document, "readyState", {
+        value: "complete",
+        writable: true,
+        configurable: true,
+      });
+      const callback = vi.fn();
+      const result = checkLoaded(callback);
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(result).toBe(true);
+    });
+
+    it("checkLoaded should schedule itself when document is not complete", () => {
+      Object.defineProperty(document, "readyState", {
+        value: "loading",
+        writable: true,
+        configurable: true,
+      });
+      const callback = vi.fn();
+      const setTimeoutSpy = vi.spyOn(global, "setTimeout");
+      checkLoaded(callback);
+      expect(callback).not.toHaveBeenCalled();
+      expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 100);
+      const scheduled = setTimeoutSpy.mock.calls[0][0];
+      Object.defineProperty(document, "readyState", {
+        value: "complete",
+        writable: true,
+        configurable: true,
+      });
+      scheduled();
+      expect(callback).toHaveBeenCalled();
+      setTimeoutSpy.mockRestore();
+    });
+
+    it("checkLoaded should return without calling callback when tryCount exceeds 600", () => {
+      Object.defineProperty(document, "readyState", {
+        value: "loading",
+        writable: true,
+        configurable: true,
+      });
+      const callback = vi.fn();
+      let scheduled: (() => void) | null = null;
+      vi.spyOn(global, "setTimeout").mockImplementation((fn: () => void) => {
+        scheduled = fn;
+        return 0 as unknown as ReturnType<typeof setTimeout>;
+      });
+      checkLoaded(callback);
+      for (let i = 0; i < 599; i++) {
+        if (scheduled) {
+          scheduled();
+          const lastCall = (global.setTimeout as ReturnType<typeof vi.fn>).mock.calls[
+            (global.setTimeout as ReturnType<typeof vi.fn>).mock.calls.length - 1
+          ];
+          scheduled = lastCall?.[0] ?? null;
+        }
+      }
+      checkLoaded(callback);
+      expect(callback).not.toHaveBeenCalled();
+      vi.mocked(global.setTimeout).mockRestore();
+    });
+  });
+});