@tomo-inc/embedded-wallet-providers 0.0.21 → 0.0.23

package/dist/index.cjs

@@ -287,15 +287,7 @@ var EmbeddedWallet = class _EmbeddedWallet {
     if (!config) {
       throw new Error("config is not initialized");
     }
-    const cacheKey = config.clientId + "-cube-oidc-token";
-    if (oidcToken) {
-      walletUtils.cache.set(cacheKey, oidcToken, false);
-    }
-    this.oidcToken = oidcToken || walletUtils.cache.get(cacheKey) || "";
-    console.log("embedded wallet login with oidcToken:", config, this.oidcToken);
-    if (!this.oidcToken) {
-      console.warn("oidcToken is not found");
-    }
+    this.oidcToken = oidcToken || "";
     return new Promise((resolve, reject) => {
       const receiveResponse = (event) => {
         var _a, _b;
@@ -345,7 +337,7 @@ var EmbeddedWallet = class _EmbeddedWallet {
           dappOrigin: window.location.origin,
           tomoStage: stage,
           tomoClientId: clientId,
-          oidcToken: this.oidcToken || "",
+          oidcToken: this.oidcToken,
           logo: logo || "",
           name: name || ""
         });
@@ -388,6 +380,8 @@ var EmbeddedWallet = class _EmbeddedWallet {
   async logout() {
     if (this.walletIframe) {
       this.walletIframe.src = `${this.walletOrigin}#logout=true`;
+      const config = this.config;
+      config && this.init(config);
     }
     window.removeEventListener("message", this.walletCloseHandler);
     window.removeEventListener("message", this.logoutListener);

package/dist/index.js

@@ -1,5 +1,5 @@
 import { TronProvider, SolanaProvider, DogecoinProvider, BitcoinProvider, EvmProvider } from '@tomo-inc/inject-providers';
-import { ChainTypeEnum, ProviderProtocol, ProviderStandard, cache } from '@tomo-inc/wallet-utils';
+import { ChainTypeEnum, ProviderProtocol, ProviderStandard } from '@tomo-inc/wallet-utils';
 import { OidcAuth } from '@tomo-inc/oidc-auth';
 
 var __defProp = Object.defineProperty;
@@ -285,15 +285,7 @@ var EmbeddedWallet = class _EmbeddedWallet {
     if (!config) {
       throw new Error("config is not initialized");
     }
-    const cacheKey = config.clientId + "-cube-oidc-token";
-    if (oidcToken) {
-      cache.set(cacheKey, oidcToken, false);
-    }
-    this.oidcToken = oidcToken || cache.get(cacheKey) || "";
-    console.log("embedded wallet login with oidcToken:", config, this.oidcToken);
-    if (!this.oidcToken) {
-      console.warn("oidcToken is not found");
-    }
+    this.oidcToken = oidcToken || "";
     return new Promise((resolve, reject) => {
       const receiveResponse = (event) => {
         var _a, _b;
@@ -343,7 +335,7 @@ var EmbeddedWallet = class _EmbeddedWallet {
           dappOrigin: window.location.origin,
           tomoStage: stage,
           tomoClientId: clientId,
-          oidcToken: this.oidcToken || "",
+          oidcToken: this.oidcToken,
           logo: logo || "",
           name: name || ""
         });
@@ -386,6 +378,8 @@ var EmbeddedWallet = class _EmbeddedWallet {
   async logout() {
     if (this.walletIframe) {
       this.walletIframe.src = `${this.walletOrigin}#logout=true`;
+      const config = this.config;
+      config && this.init(config);
     }
     window.removeEventListener("message", this.walletCloseHandler);
     window.removeEventListener("message", this.logoutListener);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomo-inc/embedded-wallet-providers",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "author": "tomo.inc",
   "license": "MIT",
   "private": false,
@@ -16,8 +16,8 @@
     }
   },
   "dependencies": {
-    "@tomo-inc/oidc-auth": "0.0.16",
-    "@tomo-inc/wallet-utils": "0.0.18",
+    "@tomo-inc/oidc-auth": "0.0.17",
+    "@tomo-inc/wallet-utils": "0.0.19",
     "@tomo-inc/inject-providers": "0.0.16"
   },
   "devDependencies": {
@@ -28,7 +28,12 @@
     "tsx": "^4.19.2",
     "typescript": "^5.0.0",
     "@vitest/browser": "^3.2.4",
+    "@vitest/coverage-v8": "^3.2.4",
     "playwright": "^1.44.1",
     "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --treeshake",
+    "test": "vitest run"
   }
 }

package/project.json

@@ -51,7 +51,7 @@
       "executor": "nx:run-commands",
       "outputs": ["{projectRoot}/coverage"],
       "options": {
-        "command": "vitest run",
+        "command": "vitest run --coverage",
         "cwd": "packages/embedded-wallet-providers"
       }
     },

package/src/__tests__/embedded-wallet.test.ts

@@ -0,0 +1,600 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { EmbeddedWallet } from "../embedded-wallet";
+
+// Mocks are defined in setup.ts to prevent @okxweb3/crypto-lib module initialization
+
+describe("EmbeddedWallet", () => {
+  let embeddedWallet: EmbeddedWallet;
+  let mockIframe: HTMLIFrameElement;
+  let originalGetElementById: typeof document.getElementById;
+  let originalCreateElement: typeof document.createElement;
+  let originalAppendChild: typeof document.body.appendChild;
+  let messageHandlers: Array<(event: MessageEvent) => void>;
+
+  beforeEach(() => {
+    embeddedWallet = EmbeddedWallet.getInstance();
+    vi.clearAllMocks();
+
+    // Mock iframe
+    mockIframe = {
+      id: "",
+      src: "",
+      style: {
+        cssText: "",
+        width: "",
+        height: "",
+        backgroundColor: "",
+      },
+      allow: "",
+      closed: false,
+      setAttribute: vi.fn(),
+      contentWindow: {
+        postMessage: vi.fn(),
+      } as any,
+    } as any;
+
+    // Mock document methods
+    originalGetElementById = document.getElementById;
+    originalCreateElement = document.createElement;
+    originalAppendChild = document.body.appendChild;
+
+    document.getElementById = vi.fn().mockReturnValue(null);
+    document.createElement = vi.fn((tagName: string) => {
+      if (tagName === "iframe") {
+        return mockIframe;
+      }
+      return originalCreateElement.call(document, tagName);
+    });
+    document.body.appendChild = vi.fn();
+
+    // Mock message event listeners
+    messageHandlers = [];
+    window.addEventListener = vi.fn((event: string, handler: any) => {
+      if (event === "message") {
+        messageHandlers.push(handler);
+      }
+    });
+    window.removeEventListener = vi.fn();
+
+    // Mock window.location
+    Object.defineProperty(window, "location", {
+      value: {
+        origin: "https://test.com",
+      },
+      writable: true,
+    });
+  });
+
+  afterEach(() => {
+    document.getElementById = originalGetElementById;
+    document.createElement = originalCreateElement;
+    document.body.appendChild = originalAppendChild;
+  });
+
+  describe("getInstance", () => {
+    it("should return singleton instance", () => {
+      const instance1 = EmbeddedWallet.getInstance();
+      const instance2 = EmbeddedWallet.getInstance();
+      expect(instance1).toBe(instance2);
+    });
+  });
+
+  describe("init", () => {
+    it("should initialize with valid config", async () => {
+      const config = {
+        clientId: "test-client-id",
+        walletBaseUrl: "https://wallet.tomo.inc",
+        name: "Test Wallet",
+        logo: "https://example.com/logo.png",
+        tomoStage: "dev" as const,
+        xClientId: "x-client-id",
+        googleClientId: "google-client-id",
+      };
+
+      // Mock login response
+      setTimeout(() => {
+        const handler = messageHandlers[0];
+        if (handler) {
+          handler({
+            origin: "https://wallet.tomo.inc",
+            data: {
+              type: "wallet-ready",
+              data: {
+                isAvailable: true,
+                connectedInfo: {
+                  evmProvider: {
+                    connected: true,
+                    address: ["0x123"],
+                  },
+                },
+              },
+            },
+          } as MessageEvent);
+        }
+      }, 10);
+
+      const result = await embeddedWallet.init(config);
+
+      expect(result.isAvailable).toBe(true);
+      expect(embeddedWallet.config).toEqual(config);
+      expect(embeddedWallet.walletOrigin).toBe("https://wallet.tomo.inc");
+    });
+
+    it("should throw error if clientId is missing", async () => {
+      const config = {
+        walletBaseUrl: "https://wallet.tomo.inc",
+        name: "Test",
+        logo: "",
+        tomoStage: "dev" as const,
+        xClientId: "x",
+        googleClientId: "g",
+      } as any;
+
+      await expect(embeddedWallet.init(config)).rejects.toThrow("clientId is required.");
+    });
+
+    it("should throw error if walletBaseUrl is missing", async () => {
+      const config = {
+        clientId: "test",
+        name: "Test",
+        logo: "",
+        tomoStage: "dev" as const,
+        xClientId: "x",
+        googleClientId: "g",
+      } as any;
+
+      await expect(embeddedWallet.init(config)).rejects.toThrow("walletBaseUrl is required.");
+    });
+
+    it("should build rdns correctly when walletBaseUrl has port", async () => {
+      const config = {
+        clientId: "port-client",
+        walletBaseUrl: "https://wallet.example.com:8080",
+        name: "Test",
+        logo: "",
+        tomoStage: "dev" as const,
+        xClientId: "x",
+        googleClientId: "g",
+      };
+
+      setTimeout(() => {
+        const handler = messageHandlers[0];
+        if (handler) {
+          handler({
+            origin: "https://wallet.example.com:8080",
+            data: {
+              type: "wallet-ready",
+              data: { isAvailable: true, connectedInfo: null },
+            },
+          } as MessageEvent);
+        }
+      }, 10);
+
+      await embeddedWallet.init(config);
+      expect(embeddedWallet.walletOrigin).toBe("https://wallet.example.com:8080");
+      expect(embeddedWallet.info?.uuid).toContain("8080");
+    });
+  });
+
+  describe("setWalletZIndex", () => {
+    it("should set mask z-index", () => {
+      embeddedWallet.setWalletZIndex(9999);
+      expect(embeddedWallet.maskZIndex).toBe(9999);
+    });
+  });
+
+  describe("popup", () => {
+    it("should show wallet iframe", () => {
+      embeddedWallet.walletIframe = mockIframe;
+      embeddedWallet.popup();
+
+      expect(mockIframe.style.cssText).toContain("position: fixed");
+      expect(mockIframe.style.cssText).toContain("z-index: 999");
+    });
+
+    it("should do nothing if walletIframe is null", () => {
+      embeddedWallet.walletIframe = null;
+      expect(() => embeddedWallet.popup()).not.toThrow();
+    });
+  });
+
+  describe("close", () => {
+    it("should hide wallet iframe", () => {
+      embeddedWallet.walletIframe = mockIframe;
+      embeddedWallet.close();
+
+      expect(mockIframe.style.width).toBe("0");
+      expect(mockIframe.style.height).toBe("0");
+    });
+
+    it("should do nothing if walletIframe is null", () => {
+      embeddedWallet.walletIframe = null;
+      expect(() => embeddedWallet.close()).not.toThrow();
+    });
+  });
+
+  describe("request", () => {
+    it("should send request to wallet iframe", async () => {
+      embeddedWallet.walletIframe = mockIframe;
+      embeddedWallet.walletOrigin = "https://wallet.tomo.inc";
+
+      // Mock response
+      setTimeout(() => {
+        const handler = messageHandlers[0];
+        if (handler) {
+          handler({
+            origin: "https://wallet.tomo.inc",
+            data: {
+              type: "wallet-response",
+              data: { result: "success" },
+            },
+          } as MessageEvent);
+        }
+      }, 10);
+
+      const result = await embeddedWallet.request("token", { test: "params" });
+
+      expect(mockIframe.contentWindow?.postMessage).toHaveBeenCalled();
+      expect(result).toEqual({ result: "success" });
+    });
+  });
+
+  describe("open", () => {
+    it("should open wallet page and show popup", () => {
+      embeddedWallet.walletIframe = mockIframe;
+      embeddedWallet.walletOrigin = "https://wallet.tomo.inc";
+
+      embeddedWallet.open("wallet", { test: "params" });
+
+      expect(mockIframe.contentWindow?.postMessage).toHaveBeenCalled();
+      expect(mockIframe.style.cssText).toContain("position: fixed");
+    });
+  });
+
+  describe("onLoginStatusChanged", () => {
+    it("should set login status callback", () => {
+      const callback = vi.fn();
+      embeddedWallet.onLoginStatusChanged(callback);
+
+      expect(embeddedWallet.loginStatusCallback).toBe(callback);
+      expect(window.addEventListener).toHaveBeenCalled();
+    });
+
+    it("should call loginStatusCallback with logout when logout message received", () => {
+      embeddedWallet.walletIframe = mockIframe;
+      embeddedWallet.walletOrigin = "https://wallet.tomo.inc";
+      const callback = vi.fn();
+      let capturedHandler: ((e: MessageEvent) => void) | null = null;
+      window.addEventListener = vi.fn((_event: string, handler: any) => {
+        messageHandlers.push(handler);
+        capturedHandler = handler;
+      });
+
+      embeddedWallet.onLoginStatusChanged(callback);
+
+      expect(capturedHandler).not.toBeNull();
+      capturedHandler!({
+        origin: "https://wallet.tomo.inc",
+        data: { type: "wallet-response", method: "logout" },
+      } as MessageEvent);
+
+      expect(callback).toHaveBeenCalledWith({ type: "logout" });
+    });
+  });
+
+  describe("themeChange", () => {
+    it("should persist theme and send theme-change request", async () => {
+      embeddedWallet.walletIframe = mockIframe;
+      embeddedWallet.walletOrigin = "https://wallet.tomo.inc";
+
+      embeddedWallet.themeChange({ mode: "dark" });
+
+      expect(embeddedWallet["themeConfig"]).toEqual({ mode: "dark" });
+      expect(mockIframe.contentWindow?.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "wallet-request",
+          data: { method: "theme-change", params: { mode: "dark" } },
+        }),
+        "https://wallet.tomo.inc",
+      );
+    });
+
+    it("should set themeConfig and call request with theme-change", () => {
+      embeddedWallet.walletIframe = mockIframe;
+      embeddedWallet.walletOrigin = "https://wallet.tomo.inc";
+      const requestSpy = vi.spyOn(embeddedWallet, "request").mockResolvedValue(undefined);
+
+      embeddedWallet.themeChange({ primary: "#000" });
+
+      expect(embeddedWallet["themeConfig"]).toEqual({ primary: "#000" });
+      expect(requestSpy).toHaveBeenCalledWith("theme-change", { primary: "#000" });
+      requestSpy.mockRestore();
+    });
+  });
+
+  describe("logout", () => {
+    it("should set iframe src to logout and remove listeners", async () => {
+      embeddedWallet.walletIframe = mockIframe;
+      embeddedWallet.walletOrigin = "https://wallet.tomo.inc";
+
+      const result = await embeddedWallet.logout();
+
+      expect(result).toBe(true);
+      expect(mockIframe.src).toBe("https://wallet.tomo.inc#logout=true");
+      expect(window.removeEventListener).toHaveBeenCalled();
+    });
+
+  });
+
+  describe("login", () => {
+    it("should throw when config is not initialized", async () => {
+      embeddedWallet.config = null;
+      await expect(embeddedWallet.login()).rejects.toThrow("config is not initialized");
+    });
+
+    it("should throw when walletBaseUrl or clientId is missing in config", async () => {
+      embeddedWallet.config = { clientId: "c", walletBaseUrl: "" } as any;
+      document.getElementById = vi.fn().mockReturnValue(null);
+      document.body.appendChild = vi.fn();
+
+      await expect(embeddedWallet.login()).rejects.toThrow("walletBaseUrl + clientId is required");
+    });
+
+    it("should reject when appendChild throws", async () => {
+      embeddedWallet.config = {
+        clientId: "test-id",
+        walletBaseUrl: "https://wallet.tomo.inc",
+        name: "Test",
+        logo: "",
+        stage: "dev",
+        xClientId: "x",
+        googleClientId: "g",
+      } as any;
+      document.getElementById = vi.fn().mockReturnValue(null);
+      document.body.appendChild = vi.fn().mockImplementation(() => {
+        throw new Error("append failed");
+      });
+
+      await expect(embeddedWallet.login()).rejects.toThrow("append failed");
+      expect(window.removeEventListener).toHaveBeenCalled();
+    });
+
+    it("should call loginStatusCallback when wallet-ready received", async () => {
+      const config = {
+        clientId: "test-client-id",
+        walletBaseUrl: "https://wallet.tomo.inc",
+        name: "Test",
+        logo: "",
+        tomoStage: "dev" as const,
+        xClientId: "x",
+        googleClientId: "g",
+      };
+      embeddedWallet.loginStatusCallback = vi.fn();
+
+      setTimeout(() => {
+        const handler = messageHandlers[0];
+        if (handler) {
+          handler({
+            origin: "https://wallet.tomo.inc",
+            data: {
+              type: "wallet-ready",
+              data: { isAvailable: true, connectedInfo: null },
+            },
+          } as MessageEvent);
+        }
+      }, 10);
+
+      await embeddedWallet.init(config);
+
+      expect(embeddedWallet.loginStatusCallback).toHaveBeenCalledWith({ type: "login" });
+    });
+
+    it("should cache oidcToken when login is called with token", async () => {
+      const config = {
+        clientId: "cache-client",
+        walletBaseUrl: "https://wallet.tomo.inc",
+        name: "Test",
+        logo: "",
+        tomoStage: "dev" as const,
+        xClientId: "x",
+        googleClientId: "g",
+      };
+      setTimeout(() => {
+        const handler = messageHandlers[0];
+        if (handler) {
+          handler({
+            origin: "https://wallet.tomo.inc",
+            data: {
+              type: "wallet-ready",
+              data: { isAvailable: true, connectedInfo: null },
+            },
+          } as MessageEvent);
+        }
+      }, 10);
+      await embeddedWallet.init(config);
+
+      const lenBefore = messageHandlers.length;
+      const loginPromise = embeddedWallet.login("cached-oidc-token");
+      expect(embeddedWallet["oidcToken"]).toBe("cached-oidc-token");
+
+      setTimeout(() => {
+        const handler = messageHandlers[lenBefore];
+        if (handler) {
+          handler({
+            origin: "https://wallet.tomo.inc",
+            data: {
+              type: "wallet-ready",
+              data: { isAvailable: true, connectedInfo: null },
+            },
+          } as MessageEvent);
+        }
+      }, 50);
+      await loginPromise;
+    }, 8000);
+
+    it("should remove existing iframe when login called with oidcToken", async () => {
+      const existingIframe = {
+        id: "existing-client",
+        remove: vi.fn(),
+        style: {},
+        setAttribute: vi.fn(),
+        allow: "",
+        contentWindow: { postMessage: vi.fn() },
+      } as any;
+      document.getElementById = vi.fn().mockReturnValue(existingIframe);
+      document.body.appendChild = vi.fn();
+
+      embeddedWallet.config = {
+        clientId: "existing-client",
+        walletBaseUrl: "https://wallet.tomo.inc",
+        name: "Test",
+        logo: "",
+        stage: "dev",
+        xClientId: "x",
+        googleClientId: "g",
+      } as any;
+
+      setTimeout(() => {
+        const handler = messageHandlers[0];
+        if (handler) {
+          handler({
+            origin: "https://wallet.tomo.inc",
+            data: {
+              type: "wallet-ready",
+              data: { isAvailable: true, connectedInfo: null },
+            },
+          } as MessageEvent);
+        }
+      }, 15);
+
+      await embeddedWallet.login("token-to-recreate-iframe");
+
+      expect(existingIframe.remove).toHaveBeenCalled();
+    }, 8000);
+
+    it("should close wallet when wallet-close message received during login", async () => {
+      const config = {
+        clientId: "close-test",
+        walletBaseUrl: "https://wallet.tomo.inc",
+        name: "Test",
+        logo: "",
+        tomoStage: "dev" as const,
+        xClientId: "x",
+        googleClientId: "g",
+      };
+
+      setTimeout(() => {
+        const handler = messageHandlers[0];
+        if (handler) {
+          handler({
+            origin: "https://wallet.tomo.inc",
+            data: { type: "wallet-close" },
+          } as MessageEvent);
+        }
+      }, 5);
+      setTimeout(() => {
+        const handler = messageHandlers[0];
+        if (handler) {
+          handler({
+            origin: "https://wallet.tomo.inc",
+            data: {
+              type: "wallet-ready",
+              data: { isAvailable: false, connectedInfo: null },
+            },
+          } as MessageEvent);
+        }
+      }, 15);
+
+      await embeddedWallet.init(config);
+      expect(embeddedWallet.walletIframe?.style.width).toBe("0");
+    }, 8000);
+
+    it("should close wallet when walletCloseHandler receives wallet-close message", async () => {
+      const config = {
+        clientId: "handler-close-test",
+        walletBaseUrl: "https://wallet.tomo.inc",
+        name: "Test",
+        logo: "",
+        tomoStage: "dev" as const,
+        xClientId: "x",
+        googleClientId: "g",
+      };
+      setTimeout(() => {
+        const handler = messageHandlers[0];
+        if (handler) {
+          handler({
+            origin: "https://wallet.tomo.inc",
+            data: {
+              type: "wallet-ready",
+              data: { isAvailable: true, connectedInfo: null },
+            },
+          } as MessageEvent);
+        }
+      }, 10);
+      await embeddedWallet.init(config);
+
+      embeddedWallet.walletIframe = mockIframe;
+      embeddedWallet.walletOrigin = "https://wallet.tomo.inc";
+      const walletCloseHandler = (embeddedWallet as any).walletCloseHandler as (ev: { origin: string; data: any }) => void;
+      walletCloseHandler({
+        origin: "https://wallet.tomo.inc",
+        data: { type: "wallet-close" },
+      });
+
+      expect(mockIframe.style.width).toBe("0");
+    }, 8000);
+  });
+
+  describe("loginByEmail", () => {
+    it("should request emailLogin and resolve with oidcToken", async () => {
+      embeddedWallet.walletIframe = mockIframe;
+      embeddedWallet.walletOrigin = "https://wallet.tomo.inc";
+
+      const loginPromise = embeddedWallet.loginByEmail({ email: "a@b.com" });
+
+      await new Promise((r) => setTimeout(r, 25));
+      const responseHandler = messageHandlers[1];
+      if (responseHandler) {
+        responseHandler({
+          origin: "https://wallet.tomo.inc",
+          data: { type: "wallet-response", data: { oidcToken: "email-oidc-token" } },
+        } as MessageEvent);
+      }
+
+      const result = await loginPromise;
+      expect(result).toBe("email-oidc-token");
+    }, 8000);
+
+    it("should reject when request fails", async () => {
+      embeddedWallet.walletIframe = mockIframe;
+      embeddedWallet.walletOrigin = "https://wallet.tomo.inc";
+      vi.spyOn(embeddedWallet, "request").mockRejectedValueOnce(new Error("network error"));
+
+      await expect(embeddedWallet.loginByEmail({ email: "a@b.com" })).rejects.toThrow("network error");
+    });
+
+    it("should resolve with empty string when wallet-close received", async () => {
+      embeddedWallet.walletIframe = mockIframe;
+      embeddedWallet.walletOrigin = "https://wallet.tomo.inc";
+
+      const handlers: Array<(e: MessageEvent) => void> = [];
+      window.addEventListener = vi.fn((_event: string, handler: any) => {
+        handlers.push(handler);
+      });
+
+      const resultPromise = embeddedWallet.loginByEmail({ email: "a@b.com" });
+
+      await new Promise((r) => setTimeout(r, 25));
+      const closeHandler = handlers[0];
+      if (closeHandler) {
+        closeHandler({
+          origin: "https://wallet.tomo.inc",
+          data: { type: "wallet-close" },
+        } as MessageEvent);
+      }
+
+      const result = await resultPromise;
+      expect(result).toBe("");
+    }, 8000);
+  });
+});

package/src/__tests__/hub.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { sendRequest, onResponse, notPorivderAPIs } from "../hub";
+
+// Mock EmbeddedWallet
+vi.mock("../embedded-wallet", () => ({
+  EmbeddedWallet: {
+    getInstance: vi.fn().mockReturnValue({
+      walletOrigin: "https://wallet.tomo.inc",
+      walletIframe: {
+        contentWindow: {
+          postMessage: vi.fn(),
+        },
+      },
+      popup: vi.fn(),
+      close: vi.fn(),
+    }),
+  },
+}));
+
+describe("hub", () => {
+  beforeEach(() => {
+    window.addEventListener = vi.fn();
+    window.removeEventListener = vi.fn();
+  });
+  describe("notPorivderAPIs", () => {
+    it("should have correct API flags", () => {
+      expect(notPorivderAPIs.keepAlive).toBe(true);
+      expect(notPorivderAPIs.wallet_getProviderState).toBe(true);
+      expect(notPorivderAPIs.wallet_sendDomainMetadata).toBe(true);
+    });
+  });
+
+  describe("sendRequest", () => {
+    it("should throw error if chainType is empty", async () => {
+      await expect(sendRequest("", { method: "test" })).rejects.toThrow(
+        "chainType or method is not allowed to be empty",
+      );
+    });
+
+    it("should throw error if method is empty", async () => {
+      await expect(sendRequest("evm", { method: "" })).rejects.toThrow(
+        "chainType or method is not allowed to be empty",
+      );
+    });
+
+    it("should return early for notProviderAPIs", async () => {
+      const result = await sendRequest("evm", { method: "keepAlive" });
+      expect(result).toBeUndefined();
+    });
+
+    it("should send request to wallet iframe", async () => {
+      const { EmbeddedWallet } = await import("../embedded-wallet");
+      const mockInstance = EmbeddedWallet.getInstance();
+
+      await sendRequest("evm", { method: "eth_requestAccounts", params: {} });
+
+      expect(mockInstance.walletIframe.contentWindow?.postMessage).toHaveBeenCalled();
+    });
+
+    it("should return early when walletOrigin or walletIframe is not set", async () => {
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const { EmbeddedWallet } = await import("../embedded-wallet");
+      vi.mocked(EmbeddedWallet.getInstance).mockReturnValueOnce({
+        walletOrigin: "",
+        walletIframe: null,
+        popup: vi.fn(),
+        close: vi.fn(),
+      } as any);
+
+      const result = await sendRequest("evm", { method: "eth_requestAccounts", params: {} });
+
+      expect(result).toBeUndefined();
+      expect(consoleSpy).toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe("onResponse", () => {
+    it("should resolve with success response", async () => {
+      let messageHandler: ((e: { origin: string; data: any }) => void) | null = null;
+      window.addEventListener = vi.fn((event: string, handler: any) => {
+        if (event === "message") messageHandler = handler;
+      });
+
+      const promise = onResponse({ method: "test" });
+
+      await new Promise((r) => setTimeout(r, 5));
+      if (messageHandler) {
+        messageHandler({
+          origin: "https://wallet.tomo.inc",
+          data: {
+            type: "dapp-response",
+            method: "test",
+            success: true,
+            data: { result: "success" },
+          },
+        });
+      }
+
+      const result = await promise;
+      expect(result).toBeDefined();
+    });
+
+    it("should reject with error response", async () => {
+      let messageHandler: ((e: { origin: string; data: any }) => void) | null = null;
+      window.addEventListener = vi.fn((event: string, handler: any) => {
+        if (event === "message") messageHandler = handler;
+      });
+
+      const promise = onResponse({ method: "test" });
+
+      await new Promise((r) => setTimeout(r, 5));
+      if (messageHandler) {
+        messageHandler({
+          origin: "https://wallet.tomo.inc",
+          data: {
+            type: "dapp-response",
+            method: "test",
+            success: false,
+            data: { error: "test error" },
+          },
+        });
+      }
+
+      await expect(promise).rejects.toEqual({ error: "test error" });
+    });
+
+    it("should ignore non-dapp-response messages", async () => {
+      let messageHandler: ((e: { origin: string; data: any }) => void) | null = null;
+      window.addEventListener = vi.fn((event: string, handler: any) => {
+        if (event === "message") messageHandler = handler;
+      });
+
+      const promise = onResponse({ method: "test" });
+      let resolved = false;
+      promise.then(() => {
+        resolved = true;
+      });
+
+      await new Promise((r) => setTimeout(r, 5));
+      if (messageHandler) {
+        messageHandler({
+          origin: "https://wallet.tomo.inc",
+          data: { type: "other-message", method: "test" },
+        });
+      }
+
+      await new Promise((r) => setTimeout(r, 20));
+      expect(resolved).toBe(false);
+    });
+  });
+});

package/src/__tests__/index.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+
+describe("embedded-wallet-providers", () => {
+  it("should export EmbeddedWallet", async () => {
+    const module = await import("../index");
+    expect(module.EmbeddedWallet).toBeDefined();
+    expect(typeof module.EmbeddedWallet.getInstance).toBe("function");
+  });
+
+  it("should return same instance when getting EmbeddedWallet from index", async () => {
+    const { EmbeddedWallet } = await import("../index");
+    const a = EmbeddedWallet.getInstance();
+    const b = EmbeddedWallet.getInstance();
+    expect(a).toBe(b);
+  });
+
+  it("should export InitConfig type", async () => {
+    const module = await import("../index");
+    expect(module).toBeDefined();
+  });
+
+  it("should export EmailLoginResult type", async () => {
+    const module = await import("../index");
+    expect(module).toBeDefined();
+  });
+});

package/src/__tests__/relay-route.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from "vitest";
+import {
+  dappPopups,
+  evmDappPopups,
+  dogeDappPopups,
+  solanaDappPopups,
+  tronDappPopups,
+  btcDappPopups,
+  shopDappPopups,
+} from "../relay-route";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
+
+describe("relay-route", () => {
+  describe("dappPopups", () => {
+    it("should have popups for all chain types", () => {
+      expect(dappPopups[ChainTypeEnum.EVM]).toBeDefined();
+      expect(dappPopups[ChainTypeEnum.DOGECOIN]).toBeDefined();
+      expect(dappPopups[ChainTypeEnum.SOLANA]).toBeDefined();
+      expect(dappPopups[ChainTypeEnum.TRON]).toBeDefined();
+      expect(dappPopups[ChainTypeEnum.BITCOIN]).toBeDefined();
+      expect(dappPopups.shop).toBeDefined();
+    });
+  });
+
+  describe("evmDappPopups", () => {
+    it("should have correct EVM popup routes", () => {
+      expect(evmDappPopups.connect).toBe("/dapp/connect");
+      expect(evmDappPopups.eth_requestAccounts).toBe("/dapp/connect");
+      expect(evmDappPopups.wallet_addEthereumChain).toBe("/dapp-evm/network-add");
+      expect(evmDappPopups.personal_sign).toBe("/dapp-evm/message-sign");
+      expect(evmDappPopups.eth_sendTransaction).toBe("/dapp-evm/tx-send");
+    });
+  });
+
+  describe("dogeDappPopups", () => {
+    it("should have correct Dogecoin popup routes", () => {
+      expect(dogeDappPopups.connect).toBe("/dapp/connect");
+      expect(dogeDappPopups.signMessage).toBe("/dapp-doge/message-sign");
+      expect(dogeDappPopups.requestTransaction).toBe("/dapp-doge/tx-send");
+    });
+  });
+
+  describe("solanaDappPopups", () => {
+    it("should have correct Solana popup routes", () => {
+      expect(solanaDappPopups.connect).toBe("/dapp/connect");
+      expect(solanaDappPopups.signMessage).toBe("/dapp-solana/message-sign");
+      expect(solanaDappPopups.signTransaction).toBe("/dapp-solana/tx-send");
+    });
+  });
+
+  describe("tronDappPopups", () => {
+    it("should have correct Tron popup routes", () => {
+      expect(tronDappPopups.connect).toBe("/dapp/connect");
+      expect(tronDappPopups.signMessage).toBe("/dapp-tron/message-sign");
+      expect(tronDappPopups.sendTransaction).toBe("/dapp-tron/tx-send");
+    });
+  });
+
+  describe("btcDappPopups", () => {
+    it("should have correct Bitcoin popup routes", () => {
+      expect(btcDappPopups.connect).toBe("/dapp/connect");
+      expect(btcDappPopups.signMessage).toBe("/dapp-btc/message-sign");
+      expect(btcDappPopups.sendBitcoin).toBe("/dapp-btc/tx-send");
+    });
+  });
+
+  describe("shopDappPopups", () => {
+    it("should have correct shop popup routes", () => {
+      expect(shopDappPopups.connect).toBe("/dapp-shop/dialog");
+      expect(shopDappPopups.welcomeDialog).toBe("/dapp-shop/dialog");
+    });
+  });
+});

package/src/__tests__/setup.ts

@@ -0,0 +1,60 @@
+// Setup file to mock problematic modules before any tests run
+// ALL mocks must be here to prevent module-level code execution
+import { vi } from "vitest";
+
+// Mock @okxweb3/crypto-lib FIRST - this is critical to prevent module-level execution
+vi.mock("@okxweb3/crypto-lib", () => ({}));
+vi.mock("@okxweb3/crypto-lib/dist/signutil/schnorr/stark", () => ({}));
+vi.mock("@okxweb3/crypto-lib/dist/signutil/schnorr", () => ({}));
+vi.mock("@okxweb3/crypto-lib/dist/signutil", () => ({}));
+
+// Mock @noble/hashes to prevent module-level initialization errors
+vi.mock("@noble/hashes", () => ({
+  sha256: vi.fn(),
+  sha512: vi.fn(),
+  ripemd160: vi.fn(),
+  hmac: vi.fn(),
+  pbkdf2: vi.fn(),
+  scrypt: vi.fn(),
+  utils: {
+    bytesToHex: vi.fn(),
+    hexToBytes: vi.fn(),
+    toBytes: vi.fn((input: any) => {
+      if (input instanceof Uint8Array) return input;
+      if (typeof input === "string") return new TextEncoder().encode(input);
+      return new Uint8Array(0);
+    }),
+  },
+  default: {},
+}));
+
+// Mock @tomo-inc/inject-providers to prevent crypto-lib initialization
+vi.mock("@tomo-inc/inject-providers", () => ({
+  BitcoinProvider: class MockBitcoinProvider {
+    constructor() {}
+  },
+  BtcProvider: class MockBtcProvider {
+    constructor() {}
+  },
+  DogecoinProvider: class MockDogecoinProvider {
+    constructor() {}
+  },
+  EvmProvider: class MockEvmProvider {
+    setConnectedStatus = vi.fn();
+    constructor() {}
+  },
+  SolanaProvider: class MockSolanaProvider {
+    constructor() {}
+  },
+  TronProvider: class MockTronProvider {
+    constructor() {}
+  },
+}));
+
+// Mock @tomo-inc/oidc-auth
+vi.mock("@tomo-inc/oidc-auth", () => ({
+  OidcAuth: vi.fn().mockReturnValue({
+    loginByGoogle: vi.fn().mockResolvedValue("google-token"),
+    loginByX: vi.fn().mockResolvedValue("x-token"),
+  }),
+}));

package/src/__tests__/utils.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect, vi } from "vitest";
+import { isMobile, openWindow } from "../utils";
+
+describe("utils", () => {
+  describe("isMobile", () => {
+    it("should detect mobile devices", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X)",
+        writable: true,
+        configurable: true,
+      });
+      expect(isMobile()).toBe(true);
+    });
+
+    it("should return false for desktop", () => {
+      Object.defineProperty(navigator, "userAgent", {
+        value: "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+        writable: true,
+        configurable: true,
+      });
+      expect(isMobile()).toBe(false);
+    });
+  });
+
+  describe("openWindow", () => {
+    it("should open window with default dimensions", () => {
+      const mockWindow = { closed: false } as Window;
+      window.open = vi.fn().mockReturnValue(mockWindow);
+
+      Object.defineProperty(window, "innerHeight", { value: 800, writable: true });
+      Object.defineProperty(window, "innerWidth", { value: 1200, writable: true });
+      Object.defineProperty(window, "screenY", { value: 0, writable: true });
+      Object.defineProperty(window, "screenX", { value: 0, writable: true });
+
+      const result = openWindow({ url: "https://example.com" });
+      expect(result).toBe(mockWindow);
+      expect(window.open).toHaveBeenCalled();
+    });
+
+    it("should return null when window.open is blocked", () => {
+      window.open = vi.fn().mockReturnValue(null);
+      Object.defineProperty(window, "innerHeight", { value: 800, writable: true });
+      Object.defineProperty(window, "innerWidth", { value: 1200, writable: true });
+      Object.defineProperty(window, "screenY", { value: 0, writable: true });
+      Object.defineProperty(window, "screenX", { value: 0, writable: true });
+
+      const result = openWindow({ url: "https://example.com" });
+      expect(result).toBeNull();
+    });
+
+    it("should return null when window.open throws", () => {
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      window.open = vi.fn().mockImplementation(() => {
+        throw new Error("popup blocked");
+      });
+      Object.defineProperty(window, "innerHeight", { value: 800, writable: true });
+      Object.defineProperty(window, "innerWidth", { value: 1200, writable: true });
+      Object.defineProperty(window, "screenY", { value: 0, writable: true });
+      Object.defineProperty(window, "screenX", { value: 0, writable: true });
+
+      const result = openWindow({ url: "https://example.com" });
+      expect(result).toBeNull();
+      consoleSpy.mockRestore();
+    });
+  });
+});

package/src/embedded-wallet.ts

@@ -8,7 +8,7 @@ import {
 import { onResponse, sendRequest } from "./hub";
 
 import { OidcAuth } from "@tomo-inc/oidc-auth";
-import { ChainTypeEnum, ProviderProtocol, ProviderStandard, cache } from "@tomo-inc/wallet-utils";
+import { ChainTypeEnum, ProviderProtocol, ProviderStandard } from "@tomo-inc/wallet-utils";
 import {
   EmbeddedWalletConfig,
   EmbeddedWalletConnectors,
@@ -151,17 +151,18 @@ export class EmbeddedWallet {
     if (!config) {
       throw new Error("config is not initialized");
     }
+    this.oidcToken = oidcToken || "";
 
     // cache oidcToken for second login(2nd reason unknown)
-    const cacheKey = config.clientId + "-cube-oidc-token";
-    if (oidcToken) {
-      cache.set(cacheKey, oidcToken, false);
-    }
-    this.oidcToken = oidcToken || cache.get(cacheKey) || "";
-    console.log("embedded wallet login with oidcToken:", config, this.oidcToken);
-    if (!this.oidcToken) {
-      console.warn("oidcToken is not found");
-    }
+    // const cacheKey = config.clientId + "-cube-oidc-token";
+    // if (oidcToken) {
+    //   cache.set(cacheKey, oidcToken, false);
+    // }
+    // this.oidcToken = oidcToken || cache.get(cacheKey) || "";
+    // console.log("embedded wallet login with oidcToken:", config, this.oidcToken);
+    // if (!this.oidcToken) {
+    //   console.warn("oidcToken is not found");
+    // }
 
     return new Promise((resolve, reject) => {
       const receiveResponse = (event: MessageEvent) => {
@@ -217,7 +218,7 @@ export class EmbeddedWallet {
           dappOrigin: window.location.origin,
           tomoStage: stage,
           tomoClientId: clientId,
-          oidcToken: this.oidcToken || "",
+          oidcToken: this.oidcToken,
           logo: logo || "",
           name: name || "",
         });
@@ -252,7 +253,8 @@ export class EmbeddedWallet {
     if (!this.walletIframe) {
       return;
     }
-    const baseCssText = "position: fixed; top: 0; left: 0; border: none; width: 100%; height: 100%; background: transparent; background-color: transparent;";
+    const baseCssText =
+      "position: fixed; top: 0; left: 0; border: none; width: 100%; height: 100%; background: transparent; background-color: transparent;";
     const maskZIndex = this.maskZIndex;
     this.walletIframe.style.cssText = `${baseCssText} z-index: ${maskZIndex};`;
     this.walletIframe.setAttribute("allowTransparency", "true");
@@ -273,6 +275,8 @@ export class EmbeddedWallet {
   public async logout(): Promise<boolean> {
     if (this.walletIframe) {
       this.walletIframe.src = `${this.walletOrigin}#logout=true`;
+      const config = this.config;
+      config && this.init(config);
     }
     window.removeEventListener("message", this.walletCloseHandler);
     window.removeEventListener("message", this.logoutListener);

package/src/hub.ts

@@ -1,4 +1,4 @@
-import { EmbeddedWallet } from "embedded-wallet";
+import { EmbeddedWallet } from "./embedded-wallet";
 import { dappPopups } from "./relay-route";
 
 export const notPorivderAPIs = {

package/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "jsdom",
+    setupFiles: ["./src/__tests__/setup.ts"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: ["node_modules/", "dist/", "**/*.config.*", "**/__tests__/**", "**/*.test.ts", "**/*.spec.ts"],
+    },
+  },
+});