@tomo-inc/inject-providers 0.0.16 → 0.0.18

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

@@ -0,0 +1,1362 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import messages from "../evm/messages";
+import { EvmProvider, initializeEvmProvider, setGlobalProvider } from "../evm/metamask";
+import { EMITTED_NOTIFICATIONS } from "../evm/utils";
+import { IProductInfo } from "../types";
+import * as utils from "../utils/index";
+
+describe("EvmProvider", () => {
+  let provider: EvmProvider;
+  let mockSendRequest: (chainType: string, data: any) => void;
+  let mockOnResponse: any;
+  let productInfo: IProductInfo;
+
+  beforeEach(() => {
+    mockSendRequest = vi.fn() as any;
+    mockOnResponse = vi.fn().mockResolvedValue({ data: null });
+
+    productInfo = {
+      name: "Test Wallet",
+      rdns: "com.test.wallet",
+      icon: "test-icon.png",
+    };
+
+    // Mock getDappInfo to prevent initialization errors
+    vi.spyOn(utils, "getDappInfo").mockResolvedValue({
+      origin: "https://test.com",
+      title: "Test",
+      desc: "Test desc",
+      favicon: "",
+    });
+
+    // Mock document.body to prevent innerText errors
+    const bodyElement = document.createElement("body");
+    Object.defineProperty(bodyElement, "innerText", {
+      value: "",
+      writable: true,
+      configurable: true,
+    });
+    Object.defineProperty(document, "body", {
+      value: bodyElement,
+      writable: true,
+      configurable: true,
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    // Clean up window.ethereum
+    delete (window as any).ethereum;
+  });
+
+  describe("constructor", () => {
+    it("should create EvmProvider instance with valid options", () => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+        logger: console,
+        maxEventListeners: 100,
+        shouldSendMetadata: true,
+      });
+
+      expect(provider).toBeInstanceOf(EvmProvider);
+      expect(provider.name).toBe("Test Wallet");
+      expect(provider.icon).toBe("test-icon.png");
+    });
+
+    it("should throw error for invalid maxEventListeners", () => {
+      expect(() => {
+        new EvmProvider(productInfo, {
+          sendRequest: mockSendRequest,
+          onResponse: mockOnResponse,
+          maxEventListeners: "invalid" as any,
+          shouldSendMetadata: true,
+        });
+      }).toThrow(messages.errors.invalidOptions("invalid", true));
+    });
+
+    it("should throw error for invalid shouldSendMetadata", () => {
+      expect(() => {
+        new EvmProvider(productInfo, {
+          sendRequest: mockSendRequest,
+          onResponse: mockOnResponse,
+          maxEventListeners: 100,
+          shouldSendMetadata: "invalid" as any,
+        });
+      }).toThrow(messages.errors.invalidOptions(100, "invalid"));
+    });
+
+    it("should use default logger if not provided", () => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+
+      expect(provider).toBeInstanceOf(EvmProvider);
+    });
+  });
+
+  describe("request", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+    });
+
+    it("should throw error if method is not provided", async () => {
+      await expect(provider.request({ method: "" } as any)).rejects.toThrow();
+    });
+
+    it("should throw error if method is not a string", async () => {
+      await expect(provider.request({ method: 123 } as any)).rejects.toThrow();
+    });
+
+    it("should throw error if args is not an object", async () => {
+      await expect(provider.request(null as any)).rejects.toThrow();
+      await expect(provider.request([] as any)).rejects.toThrow();
+    });
+
+    it("should validate wallet_addEthereumChain params", async () => {
+      await expect(
+        provider.request({
+          method: "wallet_addEthereumChain",
+          params: [],
+        }),
+      ).rejects.toThrow();
+
+      await expect(
+        provider.request({
+          method: "wallet_addEthereumChain",
+          params: [{}],
+        }),
+      ).rejects.toThrow();
+
+      await expect(
+        provider.request({
+          method: "wallet_addEthereumChain",
+          params: [{ chainName: "Test" }],
+        }),
+      ).rejects.toThrow();
+
+      mockOnResponse.mockResolvedValue({
+        data: true,
+        method: "wallet_addEthereumChain",
+      });
+
+      await provider.request({
+        method: "wallet_addEthereumChain",
+        params: [
+          {
+            chainName: "Test Chain",
+            rpcUrls: ["https://test.com"],
+            chainId: "0x1",
+            nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+          },
+        ],
+      });
+
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+
+    it("should validate personal_sign params", async () => {
+      await expect(
+        provider.request({
+          method: "personal_sign",
+          params: [],
+        }),
+      ).rejects.toThrow();
+
+      await expect(
+        provider.request({
+          method: "personal_sign",
+          params: ["0x123"],
+        }),
+      ).rejects.toThrow();
+
+      await expect(
+        provider.request({
+          method: "personal_sign",
+          params: [null, "0x123"],
+        }),
+      ).rejects.toThrow();
+
+      mockOnResponse.mockResolvedValue({
+        data: "0xsignature",
+        method: "personal_sign",
+      });
+
+      await provider.request({
+        method: "personal_sign",
+        params: ["0x123", "0x456"],
+      });
+
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+
+    it("should validate wallet_watchAsset params", async () => {
+      await expect(
+        provider.request({
+          method: "wallet_watchAsset",
+          params: { type: "ERC20" },
+        }),
+      ).rejects.toThrow();
+
+      await expect(
+        provider.request({
+          method: "wallet_watchAsset",
+          params: {
+            type: "ERC20",
+            options: {},
+          },
+        }),
+      ).rejects.toThrow();
+
+      await expect(
+        provider.request({
+          method: "wallet_watchAsset",
+          params: {
+            type: "ERC20",
+            options: { address: "0x123" },
+          },
+        }),
+      ).rejects.toThrow();
+
+      mockOnResponse.mockResolvedValue({
+        data: true,
+        method: "wallet_watchAsset",
+      });
+
+      await provider.request({
+        method: "wallet_watchAsset",
+        params: {
+          type: "ERC20",
+          options: {
+            address: "0x123",
+            symbol: "TST",
+            decimals: 18,
+          },
+        },
+      });
+
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+
+    it("should validate params type", async () => {
+      await expect(
+        provider.request({
+          method: "eth_getBalance",
+          params: "invalid" as any,
+        }),
+      ).rejects.toThrow();
+
+      await expect(
+        provider.request({
+          method: "eth_getBalance",
+          params: null as any,
+        }),
+      ).rejects.toThrow();
+    });
+
+    it("should handle _wallet_getProviderState response", async () => {
+      const accounts = ["0x123", "0x456"];
+      mockOnResponse.mockResolvedValue({
+        data: { accounts },
+        method: "_wallet_getProviderState",
+      });
+
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      await provider.request({
+        method: "_wallet_getProviderState",
+      });
+
+      // Wait for async operations
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+
+    it("should handle wallet_revokePermissions response", async () => {
+      mockOnResponse.mockResolvedValue({
+        data: true,
+        method: "wallet_revokePermissions",
+      });
+
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      await provider.request({
+        method: "wallet_revokePermissions",
+      });
+
+      // Wait for async operations
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+
+    it("should handle connect methods response", async () => {
+      const accounts = ["0x123"];
+      mockOnResponse.mockResolvedValue({
+        data: accounts,
+        method: "eth_requestAccounts",
+      });
+
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      await provider.request({
+        method: "eth_requestAccounts",
+      });
+
+      // Wait for async operations
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+
+    it("should handle wallet_switchEthereumChain response", async () => {
+      const chainId = "0x5";
+      mockOnResponse.mockResolvedValue({
+        data: chainId,
+        method: "wallet_switchEthereumChain",
+      });
+
+      const chainChangedSpy = vi.fn();
+      provider.on("chainChanged", chainChangedSpy);
+
+      await provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId }],
+      });
+
+      // Wait for async operations
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+
+    it("should handle eth_chainId response", async () => {
+      const chainId = "0x1";
+      mockOnResponse.mockResolvedValue({
+        data: chainId,
+        method: "eth_chainId",
+      });
+
+      const chainChangedSpy = vi.fn();
+      provider.on("chainChanged", chainChangedSpy);
+
+      await provider.request({
+        method: "eth_chainId",
+      });
+
+      // Wait for async operations
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      expect(mockSendRequest).toHaveBeenCalled();
+    });
+  });
+
+  describe("connect", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+    });
+
+    it("should emit connect event when accounts are returned", async () => {
+      const connectSpy = vi.spyOn(provider, "emit");
+      // Mock request to return accounts
+      vi.spyOn(provider, "request").mockResolvedValue(["0x123"] as any);
+
+      await provider.connect();
+
+      expect(connectSpy).toHaveBeenCalledWith("connect", {});
+    });
+  });
+
+  describe("disconnect", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+    });
+
+    it("should emit disconnect event when disconnected", async () => {
+      const disconnectSpy = vi.spyOn(provider, "emit");
+      // Mock request to return disconnected state
+      vi.spyOn(provider, "request").mockResolvedValue({ isConnected: false } as any);
+
+      await provider.disconnect();
+
+      expect(disconnectSpy).toHaveBeenCalledWith("disconnect", null);
+    });
+  });
+
+  describe("isConnected", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+    });
+
+    it("should return false when not connected", () => {
+      expect(provider.isConnected()).toBe(false);
+    });
+
+    it("should return true when connected", async () => {
+      // Trigger connect by emitting connect event
+      provider.emit("connect", { chainId: "0x1" });
+      expect(provider.isConnected()).toBe(true);
+    });
+  });
+
+  describe("sendAsync", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+    });
+
+    it("should call _rpcRequest with callback", () => {
+      const callback = vi.fn();
+      const payload = {
+        jsonrpc: "2.0" as const,
+        id: 1,
+        method: "eth_getBalance",
+        params: ["0x123"],
+      };
+
+      // Mock _rpcEngine.handle
+      const mockHandle = vi.fn();
+      (provider as any)._rpcEngine = {
+        handle: mockHandle,
+      };
+
+      provider.sendAsync(payload, callback);
+
+      expect(mockHandle).toHaveBeenCalledWith(payload, callback);
+    });
+  });
+
+  describe("event listeners", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+        logger: {
+          log: vi.fn(),
+          warn: vi.fn(),
+          error: vi.fn(),
+          debug: vi.fn(),
+          info: vi.fn(),
+          trace: vi.fn(),
+        },
+      });
+    });
+
+    it("should warn on deprecated addListener", () => {
+      const listener = vi.fn();
+      const warnSpy = vi.spyOn((provider as any)._log, "warn");
+
+      provider.addListener("close", listener);
+
+      expect(warnSpy).toHaveBeenCalled();
+    });
+
+    it("should warn on deprecated once", () => {
+      const listener = vi.fn();
+      const warnSpy = vi.spyOn((provider as any)._log, "warn");
+
+      provider.once("data", listener);
+
+      expect(warnSpy).toHaveBeenCalled();
+    });
+
+    it("should warn on deprecated prependListener", () => {
+      const listener = vi.fn();
+      const warnSpy = vi.spyOn((provider as any)._log, "warn");
+
+      provider.prependListener("networkChanged", listener);
+
+      expect(warnSpy).toHaveBeenCalled();
+    });
+
+    it("should warn on deprecated prependOnceListener", () => {
+      const listener = vi.fn();
+      const warnSpy = vi.spyOn((provider as any)._log, "warn");
+
+      provider.prependOnceListener("notification", listener);
+
+      expect(warnSpy).toHaveBeenCalled();
+    });
+
+    it("should not warn twice for same event", () => {
+      const listener = vi.fn();
+      const warnSpy = vi.spyOn((provider as any)._log, "warn");
+
+      provider.addListener("close", listener);
+      provider.addListener("close", listener);
+
+      expect(warnSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("JSON-RPC notifications", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+    });
+
+    it("should handle wallet_accountsChanged notification", async () => {
+      // Wait for initialization to complete
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      // Access the internal jsonRpcConnection through _rpcEngine
+      const rpcEngine = (provider as any)._rpcEngine;
+      const middlewares = (rpcEngine as any)._middleware || [];
+      const streamMiddleware = middlewares.find((m: any) => m && m.stream);
+
+      if (streamMiddleware && streamMiddleware.events) {
+        streamMiddleware.events.emit("notification", {
+          method: "wallet_accountsChanged",
+          params: [["0x123", "0x456"]],
+        });
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        expect(accountsChangedSpy).toHaveBeenCalled();
+      }
+    });
+
+    it("should handle wallet_unlockStateChanged notification", async () => {
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      const rpcEngine = (provider as any)._rpcEngine;
+      const middlewares = (rpcEngine as any)._middleware || [];
+      const streamMiddleware = middlewares.find((m: any) => m && m.stream);
+
+      if (streamMiddleware && streamMiddleware.events) {
+        streamMiddleware.events.emit("notification", {
+          method: "wallet_unlockStateChanged",
+          params: [{ accounts: ["0x123"], isUnlocked: true }],
+        });
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    });
+
+    it("should handle wallet_chainChanged notification", async () => {
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      const chainChangedSpy = vi.fn();
+      provider.on("chainChanged", chainChangedSpy);
+
+      const rpcEngine = (provider as any)._rpcEngine;
+      const middlewares = (rpcEngine as any)._middleware || [];
+      const streamMiddleware = middlewares.find((m: any) => m && m.stream);
+
+      if (streamMiddleware && streamMiddleware.events) {
+        streamMiddleware.events.emit("notification", {
+          method: "wallet_chainChanged",
+          params: [{ chainId: "0x5" }],
+        });
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    });
+
+    it("should handle EMITTED_NOTIFICATIONS", async () => {
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      const dataSpy = vi.fn();
+      const messageSpy = vi.fn();
+      const notificationSpy = vi.fn();
+
+      provider.on("data", dataSpy);
+      provider.on("message", messageSpy);
+      provider.on("notification", notificationSpy);
+
+      const rpcEngine = (provider as any)._rpcEngine;
+      const middlewares = (rpcEngine as any)._middleware || [];
+      const streamMiddleware = middlewares.find((m: any) => m && m.stream);
+
+      if (streamMiddleware && streamMiddleware.events) {
+        const notificationMethod = EMITTED_NOTIFICATIONS[0];
+        streamMiddleware.events.emit("notification", {
+          method: notificationMethod,
+          params: { result: "test" },
+        });
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    });
+
+    it("should handle WALLET_STREAM_FAILURE", async () => {
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      const rpcEngine = (provider as any)._rpcEngine;
+      const middlewares = (rpcEngine as any)._middleware || [];
+      const streamMiddleware = middlewares.find((m: any) => m && m.stream);
+
+      if (streamMiddleware && streamMiddleware.events) {
+        streamMiddleware.events.emit("notification", {
+          method: "WALLET_STREAM_FAILURE",
+          params: {},
+        });
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe("subscribeWalletEventsCallback", () => {
+    beforeEach(async () => {
+      // Mock the initial state request
+      mockOnResponse.mockResolvedValueOnce({
+        data: {
+          accounts: [],
+          chainId: "0x1",
+          isUnlocked: false,
+          isConnected: false,
+        },
+        method: "wallet_getProviderState",
+      });
+
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+      // Wait for _initializeState to complete and set up window.addEventListener
+      await new Promise((resolve) => {
+        provider.once("_initialized", resolve);
+        // Fallback timeout
+        setTimeout(resolve, 500);
+      });
+    });
+
+    it("should handle accountsChanged message", async () => {
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      // Simulate window message event
+      // Note: chainType is "evm" (lowercase) as defined by ChainTypes.EVM
+      const event = new MessageEvent("message", {
+        data: {
+          type: "subscribeWalletEvents",
+          method: "accountsChanged",
+          data: {
+            evm: [{ address: "0x123" }, { address: "0x456" }],
+          },
+        },
+      });
+
+      window.dispatchEvent(event);
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      expect(accountsChangedSpy).toHaveBeenCalled();
+    });
+
+    it("should handle chainChanged message", async () => {
+      const chainChangedSpy = vi.fn();
+      provider.on("chainChanged", chainChangedSpy);
+
+      // Note: chainType is "evm" (lowercase), so type should start with "evm:"
+      const event = new MessageEvent("message", {
+        data: {
+          type: "subscribeWalletEvents",
+          method: "chainChanged",
+          data: {
+            chainId: "5",
+            type: "evm:5",
+          },
+        },
+      });
+
+      window.dispatchEvent(event);
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      expect(chainChangedSpy).toHaveBeenCalled();
+    });
+
+    it("should ignore non-subscribeWalletEvents messages", () => {
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      const event = new MessageEvent("message", {
+        data: {
+          type: "other",
+          method: "accountsChanged",
+        },
+      });
+
+      window.dispatchEvent(event);
+
+      expect(accountsChangedSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("keepAlive", () => {
+    let keepAliveMockSendRequest: ReturnType<typeof vi.fn>;
+    let keepAliveMockOnResponse: ReturnType<typeof vi.fn>;
+    let keepAliveSpy: ReturnType<typeof vi.fn>;
+
+    beforeEach(async () => {
+      vi.useFakeTimers();
+      keepAliveMockSendRequest = vi.fn();
+
+      // Mock keepAlive response - always resolve to allow testing
+      keepAliveMockOnResponse = vi.fn().mockImplementation((args: any) => {
+        if (args?.method === "keepAlive") {
+          return Promise.resolve({
+            data: true,
+            method: "keepAlive",
+          });
+        }
+        // For other methods, return default
+        return Promise.resolve({ data: null });
+      });
+
+      // Mock initial state request
+      keepAliveMockOnResponse.mockResolvedValueOnce({
+        data: {
+          accounts: [],
+          chainId: "0x1",
+          isUnlocked: false,
+          isConnected: false,
+        },
+        method: "wallet_getProviderState",
+      });
+
+      provider = new EvmProvider(productInfo, {
+        sendRequest: keepAliveMockSendRequest as any,
+        onResponse: keepAliveMockOnResponse,
+      });
+
+      // Spy on keepAlive method to track calls
+      keepAliveSpy = vi.spyOn(provider as any, "keepAlive");
+
+      // Wait for initialization to complete
+      await new Promise((resolve) => {
+        provider.once("_initialized", resolve);
+        // Process pending timers
+        vi.runAllTicks();
+      });
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+      keepAliveSpy.mockRestore();
+    });
+
+    it("should call keepAlive periodically", async () => {
+      // Clear previous calls
+      keepAliveMockSendRequest.mockClear();
+      keepAliveSpy.mockClear();
+
+      // Fast-forward time to trigger keepAlive (1000ms interval)
+      // Advance by 1500ms to trigger at least one keepAlive call
+      vi.advanceTimersByTime(1500);
+
+      // Process only the current tick's timers, not all future timers
+      // This prevents infinite loop
+      await vi.runAllTicks();
+
+      // Verify keepAlive was called
+      expect(keepAliveSpy).toHaveBeenCalled();
+
+      // Verify sendRequest was called with keepAlive method
+      const keepAliveCalls = keepAliveMockSendRequest.mock.calls.filter((call) => call[1]?.method === "keepAlive");
+      expect(keepAliveCalls.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("_rpcRequest", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+    });
+
+    it("should handle single payload", () => {
+      const callback = vi.fn();
+      const payload: any = {
+        method: "eth_getBalance",
+        params: ["0x123"],
+      };
+
+      const mockHandle = vi.fn();
+      (provider as any)._rpcEngine = {
+        handle: mockHandle,
+      };
+
+      (provider as any)._rpcRequest(payload, callback);
+
+      expect(mockHandle).toHaveBeenCalled();
+      expect(payload.jsonrpc).toBe("2.0");
+    });
+
+    it("should handle payload with existing jsonrpc", () => {
+      const callback = vi.fn();
+      const payload = {
+        jsonrpc: "2.0",
+        method: "eth_getBalance",
+        params: ["0x123"],
+      };
+
+      const mockHandle = vi.fn();
+      (provider as any)._rpcEngine = {
+        handle: mockHandle,
+      };
+
+      (provider as any)._rpcRequest(payload, callback);
+
+      expect(mockHandle).toHaveBeenCalled();
+    });
+
+    it("should handle eth_accounts method", () => {
+      const callback = vi.fn();
+      const payload = {
+        method: "eth_accounts",
+        params: [],
+      };
+
+      const mockHandle = vi.fn((p, cb) => {
+        cb(null, { result: ["0x123"] });
+      });
+      (provider as any)._rpcEngine = {
+        handle: mockHandle,
+      };
+
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      (provider as any)._rpcRequest(payload, callback);
+
+      expect(mockHandle).toHaveBeenCalled();
+    });
+
+    it("should handle eth_requestAccounts method", () => {
+      const callback = vi.fn();
+      const payload = {
+        method: "eth_requestAccounts",
+        params: [],
+      };
+
+      const mockHandle = vi.fn((p, cb) => {
+        cb(null, { result: ["0x123"] });
+      });
+      (provider as any)._rpcEngine = {
+        handle: mockHandle,
+      };
+
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      (provider as any)._rpcRequest(payload, callback);
+
+      expect(mockHandle).toHaveBeenCalled();
+    });
+
+    it("should handle array payload", () => {
+      const callback = vi.fn();
+      const payload = [
+        {
+          jsonrpc: "2.0",
+          method: "eth_getBalance",
+          params: ["0x123"],
+        },
+      ];
+
+      const mockHandle = vi.fn();
+      (provider as any)._rpcEngine = {
+        handle: mockHandle,
+      };
+
+      (provider as any)._rpcRequest(payload, callback);
+
+      expect(mockHandle).toHaveBeenCalled();
+    });
+  });
+
+  describe("_handleConnect", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+    });
+
+    it("should emit connect event when not connected", () => {
+      const connectSpy = vi.fn();
+      provider.on("connect", connectSpy);
+
+      (provider as any)._handleConnect("0x1");
+
+      expect(connectSpy).toHaveBeenCalledWith({ chainId: "0x1" });
+      expect(provider.isConnected()).toBe(true);
+    });
+
+    it("should not emit connect event when already connected", () => {
+      provider.emit("connect", { chainId: "0x1" });
+      const connectSpy = vi.fn();
+      provider.on("connect", connectSpy);
+
+      (provider as any)._handleConnect("0x2");
+
+      // Should not emit again
+      expect(connectSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("_handleDisconnect", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+    });
+
+    it("should handle recoverable disconnect", () => {
+      provider.emit("connect", { chainId: "0x1" });
+      const disconnectSpy = vi.fn();
+      const closeSpy = vi.fn();
+
+      provider.on("disconnect", disconnectSpy);
+      provider.on("close", closeSpy);
+
+      (provider as any)._handleDisconnect(true, "Test error");
+
+      expect(disconnectSpy).toHaveBeenCalled();
+      expect(closeSpy).toHaveBeenCalled();
+      expect(provider.isConnected()).toBe(false);
+    });
+
+    it("should handle permanent disconnect", () => {
+      provider.emit("connect", { chainId: "0x1" });
+      provider.selectedAddress = "0x123";
+      provider.chainId = "0x1";
+      provider.networkVersion = "1";
+      (provider as any)._state.accounts = ["0x123"];
+
+      const disconnectSpy = vi.fn();
+      provider.on("disconnect", disconnectSpy);
+
+      (provider as any)._handleDisconnect(false, "Permanent error");
+
+      expect(disconnectSpy).toHaveBeenCalled();
+      expect(provider.chainId).toBeNull();
+      expect(provider.networkVersion).toBeNull();
+      expect(provider.selectedAddress).toBeNull();
+      expect((provider as any)._state.accounts).toBeNull();
+      expect((provider as any)._state.isPermanentlyDisconnected).toBe(true);
+    });
+
+    it("should handle disconnect when not connected", () => {
+      const disconnectSpy = vi.fn();
+      provider.on("disconnect", disconnectSpy);
+
+      (provider as any)._handleDisconnect(false);
+
+      expect(disconnectSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe("_handleChainChanged", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+    });
+
+    it("should handle valid chain change", async () => {
+      // Wait for initialization
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      const chainChangedSpy = vi.fn();
+      provider.on("chainChanged", chainChangedSpy);
+
+      (provider as any)._handleChainChanged({ chainId: "0x5", isConnected: true });
+
+      expect(provider.chainId).toBe("0x5");
+      expect(chainChangedSpy).toHaveBeenCalledWith("0x5");
+    });
+
+    it("should not emit if chainId is the same", async () => {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      provider.chainId = "0x1";
+      const chainChangedSpy = vi.fn();
+      provider.on("chainChanged", chainChangedSpy);
+
+      (provider as any)._handleChainChanged({ chainId: "0x1", isConnected: true });
+
+      expect(chainChangedSpy).not.toHaveBeenCalled();
+    });
+
+    it("should handle invalid chainId", () => {
+      const chainChangedSpy = vi.fn();
+      provider.on("chainChanged", chainChangedSpy);
+
+      (provider as any)._handleChainChanged({ chainId: "invalid", isConnected: true });
+
+      expect(chainChangedSpy).not.toHaveBeenCalled();
+    });
+
+    it("should handle disconnect when isConnected is false", () => {
+      // First set provider as connected
+      provider.emit("connect", { chainId: "0x1" });
+      expect(provider.isConnected()).toBe(true);
+
+      const disconnectSpy = vi.fn();
+      provider.on("disconnect", disconnectSpy);
+
+      (provider as any)._handleChainChanged({ chainId: "0x1", isConnected: false });
+
+      expect(disconnectSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe("_handleAccountsChanged", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+    });
+
+    it("should handle valid accounts change", async () => {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      (provider as any)._handleAccountsChanged(["0x123", "0x456"]);
+
+      expect(provider.selectedAddress).toBe("0x123");
+      expect(accountsChangedSpy).toHaveBeenCalledWith(["0x123", "0x456"]);
+    });
+
+    it("should handle empty accounts", async () => {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      provider.selectedAddress = "0x123";
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      (provider as any)._handleAccountsChanged([]);
+
+      expect(provider.selectedAddress).toBeNull();
+      expect(accountsChangedSpy).toHaveBeenCalledWith([]);
+    });
+
+    it("should handle invalid accounts parameter", () => {
+      const errorSpy = vi.spyOn((provider as any)._log, "error");
+
+      (provider as any)._handleAccountsChanged("invalid" as any);
+
+      expect(errorSpy).toHaveBeenCalled();
+    });
+
+    it("should handle non-string account", () => {
+      const errorSpy = vi.spyOn((provider as any)._log, "error");
+
+      (provider as any)._handleAccountsChanged([123 as any, "0x123"]);
+
+      expect(errorSpy).toHaveBeenCalled();
+    });
+
+    it("should not emit if accounts haven't changed", async () => {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      // Set accounts using the same array reference to ensure comparison works
+      const accounts = ["0x123"];
+      (provider as any)._state.accounts = accounts;
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      // Use the same array reference
+      (provider as any)._handleAccountsChanged(accounts);
+
+      expect(accountsChangedSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("_handleUnlockStateChanged", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+    });
+
+    it("should handle unlock state change", () => {
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      (provider as any)._handleUnlockStateChanged({
+        accounts: ["0x123"],
+        isUnlocked: true,
+      });
+
+      expect((provider as any)._state.isUnlocked).toBe(true);
+      expect(accountsChangedSpy).toHaveBeenCalled();
+    });
+
+    it("should handle invalid isUnlocked parameter", () => {
+      const errorSpy = vi.spyOn((provider as any)._log, "error");
+
+      (provider as any)._handleUnlockStateChanged({
+        isUnlocked: "invalid" as any,
+      });
+
+      expect(errorSpy).toHaveBeenCalled();
+    });
+
+    it("should not change if isUnlocked is the same", () => {
+      (provider as any)._state.isUnlocked = false;
+      const accountsChangedSpy = vi.fn();
+      provider.on("accountsChanged", accountsChangedSpy);
+
+      (provider as any)._handleUnlockStateChanged({
+        isUnlocked: false,
+      });
+
+      // Should not call accountsChanged if unlock state didn't change
+      expect((provider as any)._state.isUnlocked).toBe(false);
+    });
+  });
+
+  describe("send", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+        logger: {
+          log: vi.fn(),
+          warn: vi.fn(),
+          error: vi.fn(),
+          debug: vi.fn(),
+          info: vi.fn(),
+          trace: vi.fn(),
+        },
+      });
+    });
+
+    it("should warn on first send call", () => {
+      const warnSpy = vi.spyOn((provider as any)._log, "warn");
+
+      const mockHandle = vi.fn();
+      (provider as any)._rpcEngine = {
+        handle: mockHandle,
+      };
+
+      provider.send("eth_getBalance", ["0x123"]);
+
+      expect(warnSpy).toHaveBeenCalled();
+    });
+
+    it("should handle string method with params", async () => {
+      const mockHandle = vi.fn((payload, callback) => {
+        callback(null, { result: "0x1000" });
+      });
+      (provider as any)._rpcEngine = {
+        handle: mockHandle,
+      };
+
+      const result = await provider.send("eth_getBalance", ["0x123"]);
+
+      expect(mockHandle).toHaveBeenCalled();
+      expect(result).toBeDefined();
+    });
+
+    it("should handle payload object with callback", () => {
+      const callback = vi.fn();
+      const payload = {
+        jsonrpc: "2.0" as const,
+        id: 1,
+        method: "eth_getBalance",
+        params: ["0x123"],
+      };
+
+      const mockHandle = vi.fn();
+      (provider as any)._rpcEngine = {
+        handle: mockHandle,
+      };
+
+      provider.send(payload, callback);
+
+      expect(mockHandle).toHaveBeenCalled();
+    });
+
+    it("should handle sync methods", () => {
+      provider.selectedAddress = "0x123";
+
+      const result = provider.send({
+        jsonrpc: "2.0" as const,
+        id: 1,
+        method: "eth_accounts",
+      } as any) as any;
+
+      expect(result.result).toEqual(["0x123"]);
+    });
+
+    it("should handle eth_coinbase sync", () => {
+      provider.selectedAddress = "0x123";
+
+      const result = provider.send({
+        jsonrpc: "2.0" as const,
+        id: 1,
+        method: "eth_coinbase",
+      } as any) as any;
+
+      expect(result.result).toBe("0x123");
+    });
+
+    it("should handle eth_uninstallFilter sync", () => {
+      const mockHandle = vi.fn();
+      (provider as any)._rpcEngine = {
+        handle: mockHandle,
+      };
+
+      const result = provider.send({
+        jsonrpc: "2.0" as const,
+        id: 1,
+        method: "eth_uninstallFilter",
+        params: ["0x123"],
+      } as any) as any;
+
+      expect(result.result).toBe(true);
+      expect(mockHandle).toHaveBeenCalled();
+    });
+
+    it("should handle net_version sync", () => {
+      provider.networkVersion = "1";
+
+      const result = provider.send({
+        jsonrpc: "2.0" as const,
+        id: 1,
+        method: "net_version",
+      } as any) as any;
+
+      expect(result.result).toBe("1");
+    });
+
+    it("should throw error for unsupported sync method", () => {
+      expect(() => {
+        provider.send({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "unsupported_method",
+        } as any);
+      }).toThrow();
+    });
+  });
+
+  describe("enable", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+        logger: {
+          log: vi.fn(),
+          warn: vi.fn(),
+          error: vi.fn(),
+          debug: vi.fn(),
+          info: vi.fn(),
+          trace: vi.fn(),
+        },
+      });
+    });
+
+    it("should call connect", async () => {
+      const connectSpy = vi.spyOn(provider, "connect").mockResolvedValue(["0x123"]);
+
+      await provider.enable();
+
+      expect(connectSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe("setConnectedStatus", () => {
+    beforeEach(() => {
+      provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+    });
+
+    it("should set connected status and accounts", () => {
+      provider.setConnectedStatus({
+        connected: true,
+        address: ["0x123", "0x456"],
+      });
+
+      expect((provider as any)._state.isConnected).toBe(true);
+      expect((provider as any)._state.accounts).toEqual(["0x123", "0x456"]);
+    });
+  });
+
+  describe("initializeEvmProvider", () => {
+    it("should create provider with Proxy", () => {
+      const provider = initializeEvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+        shouldSetOnWindow: false,
+      });
+
+      expect(provider).toBeDefined();
+      // Test Proxy deleteProperty
+      delete (provider as any).testProperty;
+      expect(true).toBe(true); // Proxy should allow deletion
+    });
+
+    it("should set provider on window when shouldSetOnWindow is true", () => {
+      initializeEvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+        shouldSetOnWindow: true,
+      });
+
+      expect((window as any).ethereum).toBeDefined();
+    });
+  });
+
+  describe("setGlobalProvider", () => {
+    it("should set provider on window and dispatch event", () => {
+      const provider = new EvmProvider(productInfo, {
+        sendRequest: mockSendRequest,
+        onResponse: mockOnResponse,
+      });
+
+      const eventSpy = vi.fn();
+      window.addEventListener("ethereum#initialized", eventSpy);
+
+      setGlobalProvider(provider);
+
+      expect((window as any).ethereum).toBe(provider);
+      expect(eventSpy).toHaveBeenCalled();
+    });
+  });
+});