@tomo-inc/inject-providers 0.0.16 → 0.0.18

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

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import shimWeb3 from "../evm/shimWeb3";
+import { EvmProvider } from "../evm/metamask";
+
+describe("shimWeb3", () => {
+  let originalWindow: typeof window;
+  let mockProvider: EvmProvider;
+  let mockLog: any;
+
+  beforeEach(() => {
+    originalWindow = global.window;
+    mockLog = {
+      debug: vi.fn(),
+    };
+
+    mockProvider = {
+      request: vi.fn().mockResolvedValue(undefined),
+    } as any;
+
+    // Clear window.web3
+    delete (global.window as any).web3;
+  });
+
+  afterEach(() => {
+    global.window = originalWindow;
+    vi.restoreAllMocks();
+  });
+
+  it("should create web3 shim when window.web3 does not exist", () => {
+    shimWeb3(mockProvider, mockLog);
+
+    expect((global.window as any).web3).toBeDefined();
+    expect((global.window as any).web3.currentProvider).toBe(mockProvider);
+    expect((global.window as any).web3.__isShim__).toBe(true);
+  });
+
+  it("should not create web3 shim when window.web3 already exists", () => {
+    const existingWeb3 = { currentProvider: {} };
+    (global.window as any).web3 = existingWeb3;
+
+    shimWeb3(mockProvider, mockLog);
+
+    expect((global.window as any).web3).toBe(existingWeb3);
+    expect((global.window as any).web3.currentProvider).not.toBe(mockProvider);
+  });
+
+  it("should log web3 shim usage when accessing non-currentProvider property", async () => {
+    shimWeb3(mockProvider, mockLog);
+
+    // Access a property other than currentProvider
+    const _ = (global.window as any).web3.someProperty;
+
+    // Wait for async logging
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(mockProvider.request).toHaveBeenCalledWith({
+      method: "wallet_logWeb3ShimUsage",
+    });
+  });
+
+  it("should not log multiple times for same property access", async () => {
+    shimWeb3(mockProvider, mockLog);
+
+    // Access property multiple times
+    const _1 = (global.window as any).web3.someProperty;
+    const _2 = (global.window as any).web3.someProperty;
+
+    // Wait for async logging
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    // Should only log once
+    expect(mockProvider.request).toHaveBeenCalledTimes(1);
+  });
+
+  it("should handle logging errors gracefully", async () => {
+    mockProvider.request = vi.fn().mockRejectedValue(new Error("Logging failed"));
+
+    shimWeb3(mockProvider, mockLog);
+
+    // Access a property to trigger logging
+    const _ = (global.window as any).web3.someProperty;
+
+    // Wait for async logging
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(mockLog.debug).toHaveBeenCalledWith(
+      expect.stringContaining("Failed to log web3 shim usage"),
+      expect.any(Error),
+    );
+  });
+
+  it("should allow setting properties on web3 shim", () => {
+    shimWeb3(mockProvider, mockLog);
+
+    (global.window as any).web3.testProperty = "test";
+    expect((global.window as any).web3.testProperty).toBe("test");
+  });
+
+  it("should not log when accessing currentProvider", () => {
+    shimWeb3(mockProvider, mockLog);
+
+    const _ = (global.window as any).web3.currentProvider;
+
+    expect(mockProvider.request).not.toHaveBeenCalled();
+  });
+
+  it("should not log when accessing __isShim__ property", () => {
+    shimWeb3(mockProvider, mockLog);
+
+    const _ = (global.window as any).web3.__isShim__;
+
+    expect(mockProvider.request).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,258 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  createErrorMiddleware,
+  getRpcPromiseCallback,
+  logStreamDisconnectWarning,
+  NOOP,
+  EMITTED_NOTIFICATIONS,
+  guid,
+} from "../evm/utils";
+import { EventEmitter } from "events";
+
+describe("evm/utils", () => {
+  describe("createErrorMiddleware", () => {
+    it("should validate method is a non-empty string", () => {
+      const log = {
+        error: vi.fn(),
+      };
+      const middleware = createErrorMiddleware(log as any);
+      const req = { method: "" } as any;
+      const res = {} as any;
+      const next = vi.fn((callback) => {
+        if (callback) {
+          callback(() => {});
+        }
+      });
+
+      middleware(req, res, next);
+
+      expect(res.error).toBeDefined();
+      expect(res.error.message).toContain("method");
+      expect(next).toHaveBeenCalled();
+    });
+
+    it("should validate method is a string", () => {
+      const log = {
+        error: vi.fn(),
+      };
+      const middleware = createErrorMiddleware(log as any);
+      const req = { method: 123 } as any;
+      const res = {} as any;
+      const next = vi.fn((callback) => {
+        if (callback) {
+          callback(() => {});
+        }
+      });
+
+      middleware(req, res, next);
+
+      expect(res.error).toBeDefined();
+      expect(next).toHaveBeenCalled();
+    });
+
+    it("should pass through valid requests", () => {
+      const log = {
+        error: vi.fn(),
+      };
+      const middleware = createErrorMiddleware(log as any);
+      const req = { method: "eth_getBalance" } as any;
+      const res = {} as any;
+      const next = vi.fn((callback) => {
+        if (callback) {
+          callback(() => {});
+        }
+      });
+
+      middleware(req, res, next);
+
+      expect(res.error).toBeUndefined();
+      expect(next).toHaveBeenCalled();
+    });
+
+    it("should log errors when response has error", () => {
+      const log = {
+        error: vi.fn(),
+      };
+      const middleware = createErrorMiddleware(log as any);
+      const req = { method: "eth_getBalance" } as any;
+      const res = { error: new Error("Test error") } as any;
+      const next = vi.fn((callback) => {
+        if (callback) {
+          callback(() => {});
+        }
+      });
+
+      middleware(req, res, next);
+
+      expect(log.error).toHaveBeenCalledWith("RPC Error: Test error", res.error);
+      expect(next).toHaveBeenCalled();
+    });
+  });
+
+  describe("getRpcPromiseCallback", () => {
+    it("should reject on error", () => {
+      const resolve = vi.fn();
+      const reject = vi.fn();
+      const callback = getRpcPromiseCallback(resolve, reject);
+      const error = new Error("Test error");
+
+      callback(error, {} as any);
+
+      expect(reject).toHaveBeenCalledWith(error);
+      expect(resolve).not.toHaveBeenCalled();
+    });
+
+    it("should reject on response error", () => {
+      const resolve = vi.fn();
+      const reject = vi.fn();
+      const callback = getRpcPromiseCallback(resolve, reject);
+      const responseError = new Error("Response error");
+
+      callback(null, { error: responseError } as any);
+
+      expect(reject).toHaveBeenCalledWith(responseError);
+      expect(resolve).not.toHaveBeenCalled();
+    });
+
+    it("should resolve with result when unwrapResult is true", () => {
+      const resolve = vi.fn();
+      const reject = vi.fn();
+      const callback = getRpcPromiseCallback(resolve, reject, true);
+      const result = { data: "test" };
+
+      callback(null, { result } as any);
+
+      expect(resolve).toHaveBeenCalledWith(result);
+      expect(reject).not.toHaveBeenCalled();
+    });
+
+    it("should resolve with response when unwrapResult is false", () => {
+      const resolve = vi.fn();
+      const reject = vi.fn();
+      const callback = getRpcPromiseCallback(resolve, reject, false);
+      const response = { result: { data: "test" } };
+
+      callback(null, response as any);
+
+      expect(resolve).toHaveBeenCalledWith(response);
+      expect(reject).not.toHaveBeenCalled();
+    });
+
+    it("should resolve with response when response is array", () => {
+      const resolve = vi.fn();
+      const reject = vi.fn();
+      const callback = getRpcPromiseCallback(resolve, reject, true);
+      const response = [{ result: "test1" }, { result: "test2" }];
+
+      callback(null, response as any);
+
+      expect(resolve).toHaveBeenCalledWith(response);
+      expect(reject).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("logStreamDisconnectWarning", () => {
+    it("should log warning message", () => {
+      const log = {
+        warn: vi.fn(),
+      };
+      const emitter = new EventEmitter();
+      const error = new Error("Connection lost");
+
+      logStreamDisconnectWarning(log as any, "test-stream", error, emitter);
+
+      expect(log.warn).toHaveBeenCalled();
+      const warnCall = log.warn.mock.calls[0][0];
+      expect(warnCall).toContain('Lost connection to "test-stream"');
+    });
+
+    it("should include error stack in warning", () => {
+      const log = {
+        warn: vi.fn(),
+      };
+      const emitter = new EventEmitter();
+      const error = new Error("Connection lost");
+      error.stack = "Error: Connection lost\n    at test.js:1:1";
+
+      logStreamDisconnectWarning(log as any, "test-stream", error, emitter);
+
+      const warnCall = log.warn.mock.calls[0][0];
+      expect(warnCall).toContain(error.stack);
+    });
+
+    it("should emit error event if emitter has error listeners", () => {
+      const log = {
+        warn: vi.fn(),
+      };
+      const emitter = new EventEmitter();
+      const errorListener = vi.fn();
+      emitter.on("error", errorListener);
+      const error = new Error("Connection lost");
+
+      logStreamDisconnectWarning(log as any, "test-stream", error, emitter);
+
+      expect(errorListener).toHaveBeenCalled();
+    });
+
+    it("should not emit error event if emitter has no error listeners", () => {
+      const log = {
+        warn: vi.fn(),
+      };
+      const emitter = new EventEmitter();
+      const error = new Error("Connection lost");
+
+      logStreamDisconnectWarning(log as any, "test-stream", error, emitter);
+
+      expect(emitter.listenerCount("error")).toBe(0);
+    });
+
+    it("should handle error without stack", () => {
+      const log = { warn: vi.fn() };
+      const error = new Error("Connection lost");
+      delete (error as any).stack;
+      logStreamDisconnectWarning(log as any, "stream", error, new EventEmitter());
+      expect(log.warn).toHaveBeenCalledWith(expect.stringContaining("Lost connection"));
+      expect(log.warn.mock.calls[0][0]).not.toContain("\n    at ");
+    });
+
+    it("should not emit when emitter is null", () => {
+      const log = { warn: vi.fn() };
+      const error = new Error("Connection lost");
+      expect(() =>
+        logStreamDisconnectWarning(log as any, "stream", error, null as any),
+      ).not.toThrow();
+      expect(log.warn).toHaveBeenCalled();
+    });
+  });
+
+  describe("NOOP", () => {
+    it("should return undefined", () => {
+      expect(NOOP()).toBeUndefined();
+    });
+  });
+
+  describe("EMITTED_NOTIFICATIONS", () => {
+    it("should include eth_subscription", () => {
+      expect(EMITTED_NOTIFICATIONS).toContain("eth_subscription");
+    });
+  });
+
+  describe("guid", () => {
+    it("should generate a string starting with w-", () => {
+      const result = guid();
+      expect(result).toMatch(/^w-/);
+    });
+
+    it("should generate unique values", () => {
+      const guid1 = guid();
+      const guid2 = guid();
+      expect(guid1).not.toBe(guid2);
+    });
+
+    it("should generate valid hex string after w-", () => {
+      const result = guid();
+      const hexPart = result.replace("w-", "");
+      expect(hexPart).toMatch(/^[0-9a-f]+$/);
+    });
+  });
+});

package/src/__tests__/index.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from "vitest";
+import {
+  BitcoinProvider,
+  DogecoinProvider,
+  EvmProvider,
+  SolanaProvider,
+  TronProvider,
+} from "../index";
+
+describe("inject-providers", () => {
+  it("should export all providers", () => {
+    expect(BitcoinProvider).toBeDefined();
+    expect(DogecoinProvider).toBeDefined();
+    expect(EvmProvider).toBeDefined();
+    expect(SolanaProvider).toBeDefined();
+    expect(TronProvider).toBeDefined();
+  });
+
+  it("should export providers as classes or functions", () => {
+    expect(typeof BitcoinProvider).toBe("function");
+    expect(typeof DogecoinProvider).toBe("function");
+    expect(typeof EvmProvider).toBe("function");
+    expect(typeof SolanaProvider).toBe("function");
+    expect(typeof TronProvider).toBe("function");
+  });
+});

package/src/__tests__/messages.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect } from "vitest";
+import messages from "../evm/messages";
+
+describe("messages", () => {
+  describe("errors", () => {
+    it("should return disconnected error message", () => {
+      const message = messages.errors.disconnected();
+      expect(message).toContain("ethereum.provider");
+      expect(message).toContain("Disconnected from chain");
+    });
+
+    it("should return permanentlyDisconnected error message", () => {
+      const message = messages.errors.permanentlyDisconnected();
+      expect(message).toContain("ethereum.provider");
+      expect(message).toContain("Page reload required");
+    });
+
+    it("should return sendSiteMetadata error message", () => {
+      const message = messages.errors.sendSiteMetadata();
+      expect(message).toContain("ethereum.provider");
+      expect(message).toContain("Failed to send site metadata");
+    });
+
+    it("should return unsupportedSync error message with method", () => {
+      const method = "eth_sendTransaction";
+      const message = messages.errors.unsupportedSync(method);
+      expect(message).toContain("ethereum.provider");
+      expect(message).toContain(method);
+      expect(message).toContain("synchronous methods");
+    });
+
+    it("should return invalidDuplexStream error message", () => {
+      const message = messages.errors.invalidDuplexStream();
+      expect(message).toContain("Must provide a Node.js-style duplex stream");
+    });
+
+    it("should return invalidOptions error message with parameters", () => {
+      const maxEventListeners = 50;
+      const shouldSendMetadata = false;
+      const message = messages.errors.invalidOptions(maxEventListeners, shouldSendMetadata);
+      expect(message).toContain("Invalid options");
+      expect(message).toContain(String(maxEventListeners));
+      expect(message).toContain(String(shouldSendMetadata));
+    });
+
+    it("should return invalidRequestArgs error message", () => {
+      const message = messages.errors.invalidRequestArgs();
+      expect(message).toContain("Expected a single, non-array, object argument");
+    });
+
+    it("should return invalidRequestMethod error message", () => {
+      const message = messages.errors.invalidRequestMethod();
+      expect(message).toContain("'args.method' must be a non-empty string");
+    });
+
+    it("should return invalidRequestParams error message", () => {
+      const message = messages.errors.invalidRequestParams();
+      expect(message).toContain("'args.params' must be an object or array if provided");
+    });
+
+    it("should return invalidLoggerObject error message", () => {
+      const message = messages.errors.invalidLoggerObject();
+      expect(message).toContain("'args.logger' must be an object if provided");
+    });
+
+    it("should return invalidLoggerMethod error message with method", () => {
+      const method = "log";
+      const message = messages.errors.invalidLoggerMethod(method);
+      expect(message).toContain("'args.logger' must include required method");
+      expect(message).toContain(method);
+    });
+  });
+
+  describe("info", () => {
+    it("should return connected info message with chainId", () => {
+      const chainId = "0x1";
+      const message = messages.info.connected(chainId);
+      expect(message).toContain("ethereum.provider");
+      expect(message).toContain("Connected to chain with ID");
+      expect(message).toContain(chainId);
+    });
+  });
+
+  describe("warnings", () => {
+    it("should return enableDeprecation warning", () => {
+      const message = messages.warnings.enableDeprecation;
+      expect(message).toContain("ethereum.provider");
+      expect(message).toContain("ethereum.enable()");
+      expect(message).toContain("deprecated");
+    });
+
+    it("should return sendDeprecation warning", () => {
+      const message = messages.warnings.sendDeprecation;
+      expect(message).toContain("ethereum.provider");
+      expect(message).toContain("ethereum.send(...)");
+      expect(message).toContain("deprecated");
+    });
+
+    it("should return experimentalMethods warning", () => {
+      const message = messages.warnings.experimentalMethods;
+      expect(message).toContain("ethereum.provider");
+      expect(message).toContain("non-standard, experimental methods");
+    });
+
+    describe("events", () => {
+      it("should return close event deprecation warning", () => {
+        const message = messages.warnings.events.close;
+        expect(message).toContain("ethereum.provider");
+        expect(message).toContain("'close'");
+        expect(message).toContain("deprecated");
+        expect(message).toContain("disconnect");
+      });
+
+      it("should return data event deprecation warning", () => {
+        const message = messages.warnings.events.data;
+        expect(message).toContain("ethereum.provider");
+        expect(message).toContain("'data'");
+        expect(message).toContain("deprecated");
+        expect(message).toContain("message");
+      });
+
+      it("should return networkChanged event deprecation warning", () => {
+        const message = messages.warnings.events.networkChanged;
+        expect(message).toContain("ethereum.provider");
+        expect(message).toContain("'networkChanged'");
+        expect(message).toContain("deprecated");
+        expect(message).toContain("chainChanged");
+      });
+
+      it("should return notification event deprecation warning", () => {
+        const message = messages.warnings.events.notification;
+        expect(message).toContain("ethereum.provider");
+        expect(message).toContain("'notification'");
+        expect(message).toContain("deprecated");
+        expect(message).toContain("message");
+      });
+    });
+  });
+});

package/src/__tests__/ready-promise.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi } from "vitest";
+import { ReadyPromise } from "../utils/ready-promise";
+
+describe("ReadyPromise", () => {
+  describe("constructor", () => {
+    it("should create instance with specified count", () => {
+      const readyPromise = new ReadyPromise(3);
+      expect(readyPromise).toBeInstanceOf(ReadyPromise);
+    });
+  });
+
+  describe("check and uncheck", () => {
+    it("should mark index as checked", () => {
+      const readyPromise = new ReadyPromise(2);
+      readyPromise.check(1);
+      readyPromise.check(2);
+
+      // After all checks, tasks should proceed
+      const task1 = vi.fn().mockResolvedValue("result1");
+      const promise1 = readyPromise.call(task1);
+
+      return promise1.then(() => {
+        expect(task1).toHaveBeenCalled();
+      });
+    });
+
+    it("should uncheck index", () => {
+      const readyPromise = new ReadyPromise(2);
+      readyPromise.check(1);
+      readyPromise.check(2);
+      readyPromise.uncheck(1);
+
+      // After uncheck, tasks should not proceed
+      const task1 = vi.fn().mockResolvedValue("result1");
+      const promise1 = readyPromise.call(task1);
+
+      // Wait a bit to ensure task doesn't execute
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          expect(task1).not.toHaveBeenCalled();
+          resolve(undefined);
+        }, 100);
+      });
+    });
+
+    it("should proceed only when all checks are done", async () => {
+      const readyPromise = new ReadyPromise(3);
+      const task1 = vi.fn().mockResolvedValue("result1");
+      const promise1 = readyPromise.call(task1);
+
+      // Task should not execute yet
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(task1).not.toHaveBeenCalled();
+
+      // Check first two
+      readyPromise.check(1);
+      readyPromise.check(2);
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(task1).not.toHaveBeenCalled();
+
+      // Check third - now should proceed
+      readyPromise.check(3);
+      await promise1;
+      expect(task1).toHaveBeenCalled();
+    });
+  });
+
+  describe("call", () => {
+    it("should execute function when all checks are done", async () => {
+      const readyPromise = new ReadyPromise(2);
+      readyPromise.check(1);
+      readyPromise.check(2);
+
+      const task = vi.fn().mockResolvedValue("result");
+      const result = await readyPromise.call(task);
+
+      expect(task).toHaveBeenCalled();
+      expect(result).toBe("result");
+    });
+
+    it("should queue multiple tasks and execute them in order", async () => {
+      const readyPromise = new ReadyPromise(1);
+      readyPromise.check(1);
+
+      const task1 = vi.fn().mockResolvedValue("result1");
+      const task2 = vi.fn().mockResolvedValue("result2");
+      const task3 = vi.fn().mockResolvedValue("result3");
+
+      const promise1 = readyPromise.call(task1);
+      const promise2 = readyPromise.call(task2);
+      const promise3 = readyPromise.call(task3);
+
+      const results = await Promise.all([promise1, promise2, promise3]);
+
+      expect(task1).toHaveBeenCalled();
+      expect(task2).toHaveBeenCalled();
+      expect(task3).toHaveBeenCalled();
+      expect(results).toEqual(["result1", "result2", "result3"]);
+    });
+
+    it("should handle async functions", async () => {
+      const readyPromise = new ReadyPromise(1);
+      readyPromise.check(1);
+
+      const task = vi.fn().mockImplementation(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        return "async-result";
+      });
+
+      const result = await readyPromise.call(task);
+      expect(result).toBe("async-result");
+    });
+  });
+});