@tomo-inc/inject-providers 0.0.16 → 0.0.18

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

@@ -0,0 +1,375 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { PhantomProvider } from "../solana/phantom";
+import { IProductInfo, IConnectors } from "../types";
+import { PublicKey, Transaction } from "@solana/web3.js";
+import * as utils from "../utils/index";
+import * as solanaUtils from "../solana/utils";
+
+describe("PhantomProvider", () => {
+  let provider: PhantomProvider;
+  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.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  describe("constructor", () => {
+    it("should create PhantomProvider instance", () => {
+      provider = new PhantomProvider(productInfo, connectors);
+      expect(provider).toBeInstanceOf(PhantomProvider);
+      expect(provider.name).toBe("Test Wallet");
+      expect(provider.icon).toBe("test-icon.png");
+    });
+
+    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 PhantomProvider(productInfo, connectors);
+      provider._state.initialized = true;
+      const emitSpy = vi.spyOn(provider, "emit");
+      if (messageHandler) {
+        messageHandler({
+          data: {
+            type: "subscribeWalletEvents",
+            method: "accountsChanged",
+            data: { solana: [{ publicKey: "11111111111111111111111111111111" }] },
+          },
+        } as MessageEvent);
+      }
+      expect(emitSpy).toHaveBeenCalledWith("accountChanged", expect.any(PublicKey));
+    });
+
+    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 PhantomProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({});
+      Object.defineProperty(document, "visibilityState", {
+        value: "visible",
+        writable: true,
+        configurable: true,
+      });
+      if (visibilityHandler) await visibilityHandler();
+      expect(mockSendRequest).toHaveBeenCalledWith(
+        "solana",
+        expect.objectContaining({ method: "wallet_sendDomainMetadata" }),
+      );
+    });
+
+  });
+
+  describe("_request", () => {
+    beforeEach(() => {
+      provider = new PhantomProvider(productInfo, connectors);
+    });
+
+    it("should throw error if method is not provided", async () => {
+      await expect(provider._request({} as any)).rejects.toThrow();
+    });
+
+    it("should return response data", async () => {
+      const expectedData = { publicKey: "11111111111111111111111111111111" };
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: expectedData }));
+      const result = await provider._request({ method: "connect" });
+
+      expect(result).toBeDefined();
+    });
+
+    it("should convert publicKey to PublicKey object", async () => {
+      const publicKey = "11111111111111111111111111111111";
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: { publicKey } }));
+      const result: any = await provider._request({ method: "connect" });
+
+      expect(result?.publicKey).toBeInstanceOf(PublicKey);
+    });
+  });
+
+  describe("request", () => {
+    beforeEach(() => {
+      provider = new PhantomProvider(productInfo, connectors);
+    });
+
+    it("should handle signMessage method", async () => {
+      const message = new Uint8Array([1, 2, 3]);
+      mockOnResponse.mockImplementation(() => Promise.resolve({ data: { signature: "0x123" } }));
+      await provider.request({ method: "signMessage", params: { message } }, undefined);
+
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+  });
+
+  describe("on", () => {
+    beforeEach(() => {
+      provider = new PhantomProvider(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 PhantomProvider(productInfo, connectors);
+      provider._state.initialized = true;
+    });
+
+    it("should handle accountsChanged event", () => {
+      const accountChangedSpy = vi.spyOn(provider, "emit");
+      const accounts = [{ publicKey: "11111111111111111111111111111111" }];
+
+      provider.subscribeWalletEventsCallback({
+        method: "accountsChanged",
+        data: { sol: accounts },
+      });
+
+      expect(accountChangedSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe("connect", () => {
+    beforeEach(() => {
+      provider = new PhantomProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: { publicKey: "11111111111111111111111111111111" } });
+    });
+
+    it("should call _request and emit connect", async () => {
+      const result = await provider.connect();
+      expect(mockSendRequest).toHaveBeenCalled();
+      expect(result?.publicKey).toBeInstanceOf(PublicKey);
+    });
+  });
+
+  describe("disconnect", () => {
+    beforeEach(() => {
+      provider = new PhantomProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: null });
+    });
+
+    it("should call _request and clear publicKey", async () => {
+      await provider.disconnect();
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+  });
+
+  describe("getAccount", () => {
+    beforeEach(() => {
+      provider = new PhantomProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: { address: "11111111111111111111111111111111" } });
+    });
+
+    it("should request getAccount", async () => {
+      const result = await provider.getAccount();
+      expect(mockSendRequest).toHaveBeenCalledWith("solana", expect.objectContaining({ method: "getAccount" }));
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("signMessage (direct)", () => {
+    const validSigHex = "0x" + "00".repeat(64);
+
+    beforeEach(() => {
+      provider = new PhantomProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: { signature: validSigHex, signedMessage: "hello" } });
+    });
+
+    it("should sign message and adapt response", async () => {
+      const result = await provider.signMessage(new Uint8Array([1, 2, 3]), "utf8");
+      expect(mockSendRequest).toHaveBeenCalled();
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("signIn", () => {
+    const validSigHex = "0x" + "00".repeat(64);
+
+    beforeEach(() => {
+      provider = new PhantomProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: { signature: validSigHex, signedMessage: "msg" } });
+    });
+
+    it("should call signIn with params", async () => {
+      const result = await provider.signIn({ statement: "Sign in", nonce: "n1" });
+      expect(mockSendRequest).toHaveBeenCalled();
+      expect(result).toBeDefined();
+    });
+
+    it("should include version, issuedAt, resources in signIn message", async () => {
+      await provider.signIn({
+        statement: "Hi",
+        version: "1",
+        nonce: "n",
+        issuedAt: "2024-01-01",
+        resources: ["https://example.com" as `https://${string}`],
+      });
+      expect(mockSendRequest).toHaveBeenCalled();
+      const call = mockSendRequest.mock.calls.find((c: any[]) => c[1]?.params?.message?.includes("Version:1"));
+      expect(call).toBeDefined();
+      expect(call[1].params.message).toContain("Issued At:2024-01-01");
+      expect(call[1].params.message).toContain("Resources:");
+    });
+  });
+
+  describe("signTransaction", () => {
+    beforeEach(() => {
+      vi.spyOn(solanaUtils, "txToHex").mockReturnValue("deadbeef");
+      vi.spyOn(solanaUtils, "hexToTx").mockReturnValue(new Transaction());
+      provider = new PhantomProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: { signature: "00".repeat(64) } });
+    });
+
+    it("should sign transaction", async () => {
+      const result = await provider.signTransaction(new Transaction());
+      expect(mockSendRequest).toHaveBeenCalledWith("solana", expect.objectContaining({ method: "signTransaction" }));
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("signAllTransactions", () => {
+    beforeEach(() => {
+      vi.spyOn(solanaUtils, "txToHex").mockReturnValue("deadbeef");
+      provider = new PhantomProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: ["sig1", "sig2"] });
+    });
+
+    it("should sign multiple transactions", async () => {
+      const result = await provider.signAllTransactions([new Transaction(), new Transaction()]);
+      expect(mockSendRequest).toHaveBeenCalledWith("solana", expect.objectContaining({ method: "signAllTransactions" }));
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("signAndSendTransaction", () => {
+    beforeEach(() => {
+      vi.spyOn(solanaUtils, "txToHex").mockReturnValue("deadbeef");
+      provider = new PhantomProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: { signature: "base58sig" } });
+    });
+
+    it("should sign and send transaction", async () => {
+      const result = await provider.signAndSendTransaction(new Transaction());
+      expect(mockSendRequest).toHaveBeenCalled();
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("signAndSendAllTransactions", () => {
+    beforeEach(() => {
+      vi.spyOn(solanaUtils, "txToHex").mockReturnValue("deadbeef");
+      provider = new PhantomProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: null });
+    });
+
+    it("should sign and send all transactions", async () => {
+      const result = await provider.signAndSendAllTransactions([new Transaction()]);
+      expect(mockSendRequest).toHaveBeenCalledWith("solana", expect.objectContaining({ method: "signAndSendAllTransactions" }));
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("sendSolana", () => {
+    beforeEach(() => {
+      provider = new PhantomProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: { signature: "hexsig" } });
+    });
+
+    it("should send solana tx", async () => {
+      const result = await provider.sendSolana({ from: "addr1", to: "addr2", amount: 1 });
+      expect(mockSendRequest).toHaveBeenCalledWith("solana", expect.objectContaining({ method: "sendSolana" }));
+      expect(result).toBeDefined();
+    });
+
+    it("should handle base58 signature in sendSolana response", async () => {
+      const base58Sig = "2NEpo7TZRRrLZSi2U";
+      mockOnResponse.mockResolvedValue({ data: { signature: base58Sig } });
+      const result = await provider.sendSolana({ from: "addr1", to: "addr2", amount: 1 });
+      expect(result).toBeDefined();
+      expect((result as any)?.signature).toBeDefined();
+    });
+  });
+
+  describe("sendToken", () => {
+    beforeEach(() => {
+      provider = new PhantomProvider(productInfo, connectors);
+      mockOnResponse.mockResolvedValue({ data: { signature: "hexsig" } });
+    });
+
+    it("should send token tx", async () => {
+      const result = await provider.sendToken({ from: "addr1", to: "addr2", amount: 1, tokenAddress: "mint" });
+      expect(mockSendRequest).toHaveBeenCalledWith("solana", expect.objectContaining({ method: "sendToken" }));
+      expect(result).toBeDefined();
+    });
+
+    it("should handle hex signature in sendToken response", async () => {
+      const hexSig = "0x" + "00".repeat(64);
+      mockOnResponse.mockResolvedValue({ data: { signature: hexSig } });
+      const result = await provider.sendToken({ from: "addr1", to: "addr2", amount: 1, tokenAddress: "mint" });
+      expect(result).toBeDefined();
+      expect((result as any)?.signature).toBeInstanceOf(Uint8Array);
+    });
+  });
+
+  describe("_handleAccountsChanged branches", () => {
+    beforeEach(() => {
+      provider = new PhantomProvider(productInfo, connectors);
+      provider._state.initialized = true;
+    });
+
+    it("should not set publicKey when first account has no publicKey or address", () => {
+      provider.subscribeWalletEventsCallback({
+        method: "accountsChanged",
+        data: { solana: [{}] },
+      });
+      expect(provider.publicKey).toBeNull();
+    });
+  });
+});

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

@@ -0,0 +1,60 @@
+import { describe, it, expect } from "vitest";
+import { Transaction, VersionedTransaction } from "@solana/web3.js";
+import { txToHex, hexToTx } from "../solana/utils";
+
+describe("solana/utils", () => {
+  describe("txToHex", () => {
+    it("should return string as-is if input is already a string", () => {
+      const hexString = "0x123456";
+      const result = txToHex(hexString as any);
+      expect(result).toBe(hexString);
+    });
+
+    it("should serialize VersionedTransaction to hex", () => {
+      // Create a minimal VersionedTransaction-like object
+      const mockTx = {
+        message: {},
+        signatures: [new Uint8Array(64)],
+        serialize: () => Buffer.from("test-transaction-data"),
+      } as unknown as VersionedTransaction;
+
+      const result = txToHex(mockTx);
+      expect(result).toBe("746573742d7472616e73616374696f6e2d64617461");
+    });
+
+    it("should serialize Transaction to hex", () => {
+      const mockTx = {
+        serialize: (options?: { requireAllSignatures?: boolean; verifySignatures?: boolean }) => {
+          return Buffer.from("test-transaction-data");
+        },
+      } as unknown as Transaction;
+
+      const result = txToHex(mockTx);
+      expect(result).toBe("746573742d7472616e73616374696f6e2d64617461");
+    });
+
+    it("should serialize Transaction with options", () => {
+      const mockTx = {
+        serialize: (options?: { requireAllSignatures?: boolean; verifySignatures?: boolean }) => {
+          expect(options?.requireAllSignatures).toBe(false);
+          expect(options?.verifySignatures).toBe(false);
+          return Buffer.from("test-transaction-data");
+        },
+      } as unknown as Transaction;
+
+      const result = txToHex(mockTx);
+      expect(result).toBe("746573742d7472616e73616374696f6e2d64617461");
+    });
+  });
+
+  describe("hexToTx", () => {
+    it("should throw error for invalid hex string", () => {
+      const invalidHex = "invalid-hex-string";
+      expect(() => hexToTx(invalidHex)).toThrow("Failed to deserialize transaction");
+    });
+
+    it("should handle empty hex string", () => {
+      expect(() => hexToTx("")).toThrow();
+    });
+  });
+});