@tomo-inc/wallet-utils 0.0.18 → 0.0.19

package/dist/index.cjs

@@ -11,6 +11,7 @@ var cache_exports = {};
 __export(cache_exports, {
   clear: () => clear,
   get: () => get,
+  isKeyExist: () => isKeyExist,
   remove: () => remove,
   set: () => set,
   setKeyNS: () => setKeyNS
@@ -323,21 +324,25 @@ function calcCtrLength(str) {
 
 // src/index.ts
 var CubeStages = {
+  "prod-dogeos": "prod",
   prod: "prod",
   pre: "prod",
   dev: "gamma"
 };
 var CubeOrgIds = {
+  "prod-dogeos": "Org#49944bce-9daf-423f-a982-269f6d0d301b",
   prod: "Org#49944bce-9daf-423f-a982-269f6d0d301b",
   pre: "Org#71c13f6d-b992-4660-874d-2ae0fadc789f",
   dev: "Org#3d07a75a-1188-4bd0-acfa-671a198b83eb"
 };
 var RelayOrigins = {
+  "prod-dogeos": "https://social-relay.tomo.inc",
   prod: "https://social-relay.tomo.inc",
   pre: "https://social-relay.tomo.inc",
   dev: "https://social-relay-dev.tomo.inc"
 };
 var TomoApiDomains = {
+  "prod-dogeos": "https://mydoge-wallet.tomo.inc",
   prod: "https://wallet-pro.tomo.inc",
   pre: "https://wallet-pre-wlfi.tomo.inc",
   dev: "https://wallet-test.tomo.inc"

package/dist/index.d.cts

@@ -2,15 +2,17 @@ declare function get(key: string): any;
 declare function set(key: string, val: any, isTemp: boolean): boolean;
 declare function remove(key: string): void;
 declare function clear(): void;
+declare function isKeyExist(key: string): boolean;
 declare function setKeyNS(NS: string): void;
 
 declare const cache_clear: typeof clear;
 declare const cache_get: typeof get;
+declare const cache_isKeyExist: typeof isKeyExist;
 declare const cache_remove: typeof remove;
 declare const cache_set: typeof set;
 declare const cache_setKeyNS: typeof setKeyNS;
 declare namespace cache {
-  export { cache_clear as clear, cache_get as get, cache_remove as remove, cache_set as set, cache_setKeyNS as setKeyNS };
+  export { cache_clear as clear, cache_get as get, cache_isKeyExist as isKeyExist, cache_remove as remove, cache_set as set, cache_setKeyNS as setKeyNS };
 }
 
 declare const getBrowserName: () => string;
@@ -66,24 +68,28 @@ declare function calcCtrLength(str: string): {
     originLen: number;
 };
 
-type TomoStage = "prod" | "pre" | "dev";
+type TomoStage = "prod" | "pre" | "dev" | "prod-dogeos";
 type CubeStage = "gamma" | "prod";
 declare const CubeStages: {
+    "prod-dogeos": string;
     prod: string;
     pre: string;
     dev: string;
 };
 declare const CubeOrgIds: {
+    "prod-dogeos": string;
     prod: string;
     pre: string;
     dev: string;
 };
 declare const RelayOrigins: {
+    "prod-dogeos": string;
     prod: string;
     pre: string;
     dev: string;
 };
 declare const TomoApiDomains: {
+    "prod-dogeos": string;
     prod: string;
     pre: string;
     dev: string;

package/dist/index.d.ts

@@ -2,15 +2,17 @@ declare function get(key: string): any;
 declare function set(key: string, val: any, isTemp: boolean): boolean;
 declare function remove(key: string): void;
 declare function clear(): void;
+declare function isKeyExist(key: string): boolean;
 declare function setKeyNS(NS: string): void;
 
 declare const cache_clear: typeof clear;
 declare const cache_get: typeof get;
+declare const cache_isKeyExist: typeof isKeyExist;
 declare const cache_remove: typeof remove;
 declare const cache_set: typeof set;
 declare const cache_setKeyNS: typeof setKeyNS;
 declare namespace cache {
-  export { cache_clear as clear, cache_get as get, cache_remove as remove, cache_set as set, cache_setKeyNS as setKeyNS };
+  export { cache_clear as clear, cache_get as get, cache_isKeyExist as isKeyExist, cache_remove as remove, cache_set as set, cache_setKeyNS as setKeyNS };
 }
 
 declare const getBrowserName: () => string;
@@ -66,24 +68,28 @@ declare function calcCtrLength(str: string): {
     originLen: number;
 };
 
-type TomoStage = "prod" | "pre" | "dev";
+type TomoStage = "prod" | "pre" | "dev" | "prod-dogeos";
 type CubeStage = "gamma" | "prod";
 declare const CubeStages: {
+    "prod-dogeos": string;
     prod: string;
     pre: string;
     dev: string;
 };
 declare const CubeOrgIds: {
+    "prod-dogeos": string;
     prod: string;
     pre: string;
     dev: string;
 };
 declare const RelayOrigins: {
+    "prod-dogeos": string;
     prod: string;
     pre: string;
     dev: string;
 };
 declare const TomoApiDomains: {
+    "prod-dogeos": string;
     prod: string;
     pre: string;
     dev: string;

package/dist/index.js

@@ -9,6 +9,7 @@ var cache_exports = {};
 __export(cache_exports, {
   clear: () => clear,
   get: () => get,
+  isKeyExist: () => isKeyExist,
   remove: () => remove,
   set: () => set,
   setKeyNS: () => setKeyNS
@@ -321,21 +322,25 @@ function calcCtrLength(str) {
 
 // src/index.ts
 var CubeStages = {
+  "prod-dogeos": "prod",
   prod: "prod",
   pre: "prod",
   dev: "gamma"
 };
 var CubeOrgIds = {
+  "prod-dogeos": "Org#49944bce-9daf-423f-a982-269f6d0d301b",
   prod: "Org#49944bce-9daf-423f-a982-269f6d0d301b",
   pre: "Org#71c13f6d-b992-4660-874d-2ae0fadc789f",
   dev: "Org#3d07a75a-1188-4bd0-acfa-671a198b83eb"
 };
 var RelayOrigins = {
+  "prod-dogeos": "https://social-relay.tomo.inc",
   prod: "https://social-relay.tomo.inc",
   pre: "https://social-relay.tomo.inc",
   dev: "https://social-relay-dev.tomo.inc"
 };
 var TomoApiDomains = {
+  "prod-dogeos": "https://mydoge-wallet.tomo.inc",
   prod: "https://wallet-pro.tomo.inc",
   pre: "https://wallet-pre-wlfi.tomo.inc",
   dev: "https://wallet-test.tomo.inc"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomo-inc/wallet-utils",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "author": "tomo.inc",
   "license": "MIT",
   "private": false,
@@ -20,9 +20,10 @@
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "4.0.14",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.14"
   },
   "scripts": {
     "build": "tsup"

package/project.json

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

package/src/__tests__/browser.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { getBrowserName } from "../broswer";
+
+describe("browser utilities", () => {
+  const originalWindow = global.window;
+  const originalNavigator = global.navigator;
+
+  beforeEach(() => {
+    // Reset window and navigator
+    delete (global as any).window;
+    delete (global as any).navigator;
+  });
+
+  afterEach(() => {
+    global.window = originalWindow;
+    global.navigator = originalNavigator;
+  });
+
+  describe("getBrowserName", () => {
+    it("should return empty string in Node.js environment", () => {
+      expect(getBrowserName()).toBe("");
+    });
+
+    it("should detect Chrome", () => {
+      (global as any).window = {
+        navigator: {
+          userAgent:
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        },
+      };
+      expect(getBrowserName()).toBe("Chrome");
+    });
+
+    it("should detect Safari", () => {
+      (global as any).window = {
+        navigator: {
+          userAgent:
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",
+        },
+      };
+      expect(getBrowserName()).toBe("Safari");
+    });
+
+    it("should detect Firefox", () => {
+      (global as any).window = {
+        navigator: {
+          userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
+        },
+      };
+      expect(getBrowserName()).toBe("Firefox");
+    });
+
+    it("should detect Edge", () => {
+      (global as any).window = {
+        navigator: {
+          userAgent:
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0",
+        },
+      };
+      expect(getBrowserName()).toBe("Edge");
+    });
+
+    it("should detect Opera", () => {
+      // According to the code, Chrome detection (line 22) comes before Opera detection (line 32)
+      // So if userAgent contains "Chrome/", it will be detected as Chrome
+      // We test with Opera/ prefix (older Opera versions that don't include Chrome/)
+      (global as any).window = {
+        navigator: {
+          userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Opera/12.0",
+        },
+      };
+      expect(getBrowserName()).toBe("Opera");
+    });
+
+    it("should detect Opera with OPR (but will be detected as Chrome due to code order)", () => {
+      // Modern Opera includes "Chrome/" in userAgent, so it will be detected as Chrome
+      // This test documents the actual behavior
+      (global as any).window = {
+        navigator: {
+          userAgent:
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 OPR/106.0.0.0",
+        },
+      };
+      // Due to code order, Chrome detection comes first, so this returns "Chrome"
+      expect(getBrowserName()).toBe("Chrome");
+    });
+
+    it("should detect Brave when userAgent does not contain Chrome/ or Safari/", () => {
+      // Brave detection relies on navigator.brave
+      // But Chrome detection (line 22) comes before Brave detection (line 26)
+      // Also Safari detection (line 9) comes before Brave
+      // So we need userAgent that doesn't match Safari or Chrome
+      // We test with userAgent that doesn't have Chrome/ or Safari/ but has brave property
+      (global as any).window = {
+        navigator: {
+          userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)",
+          brave: {
+            isBrave: vi.fn(() => true),
+          },
+        },
+      };
+      expect(getBrowserName()).toBe("Brave");
+    });
+
+    it("should detect Chrome even with brave property when userAgent contains Chrome/", () => {
+      // This documents the actual behavior: Chrome detection comes before Brave
+      // So even if navigator.brave exists, if userAgent has "Chrome/", it returns "Chrome"
+      (global as any).window = {
+        navigator: {
+          userAgent:
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+          brave: {
+            isBrave: vi.fn(() => true),
+          },
+        },
+      };
+      // Due to code order, Chrome detection comes first
+      expect(getBrowserName()).toBe("Chrome");
+    });
+
+    it("should return empty string for unknown browser", () => {
+      (global as any).window = {
+        navigator: {
+          userAgent: "Unknown Browser/1.0",
+        },
+      };
+      expect(getBrowserName()).toBe("");
+    });
+  });
+});

package/src/__tests__/cache.test.ts

@@ -0,0 +1,215 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { get, set, remove, clear, isKeyExist, setKeyNS } from "../cache";
+
+// Mock localStorage and sessionStorage
+const createStorageMock = () => {
+  const store: Record<string, string> = {};
+  const mock: any = {
+    getItem: vi.fn((key: string) => store[key] || null),
+    setItem: vi.fn((key: string, value: string) => {
+      store[key] = value.toString();
+      // Also set as property for hasOwnProperty check
+      mock[key] = value.toString();
+    }),
+    removeItem: vi.fn((key: string) => {
+      delete store[key];
+      delete mock[key];
+    }),
+    clear: vi.fn(() => {
+      Object.keys(store).forEach((key) => {
+        delete store[key];
+        delete mock[key];
+      });
+    }),
+    get length() {
+      return Object.keys(store).length;
+    },
+    key: vi.fn((index: number) => Object.keys(store)[index] || null),
+  };
+
+  return mock;
+};
+
+const localStorageMock = createStorageMock();
+const sessionStorageMock = createStorageMock();
+
+describe("cache utilities", () => {
+  beforeEach(() => {
+    // Reset stores
+    localStorageMock.clear();
+    sessionStorageMock.clear();
+    // Reset mocks
+    vi.clearAllMocks();
+    // Set up window object
+    (global as any).window = {
+      localStorage: localStorageMock,
+      sessionStorage: sessionStorageMock,
+    };
+    // Reset key namespace
+    setKeyNS("tomo-");
+  });
+
+  describe("set and get", () => {
+    it("should set and get value from localStorage", () => {
+      const result = set("test-key", "test-value", false);
+      expect(result).toBe(true);
+      expect(localStorageMock.setItem).toHaveBeenCalled();
+
+      const value = get("test-key");
+      expect(value).toBe("test-value");
+    });
+
+    it("should set and get value from sessionStorage", () => {
+      const result = set("test-key", "test-value", true);
+      expect(result).toBe(true);
+      expect(sessionStorageMock.setItem).toHaveBeenCalled();
+
+      const value = get("test-key");
+      expect(value).toBe("test-value");
+    });
+
+    it("should set and get complex objects", () => {
+      const obj = { name: "test", count: 123 };
+      set("obj-key", obj, false);
+      const value = get("obj-key");
+      expect(value).toEqual(obj);
+    });
+
+    it("should set and get arrays", () => {
+      const arr = [1, 2, 3];
+      set("arr-key", arr, false);
+      const value = get("arr-key");
+      expect(value).toEqual(arr);
+    });
+  });
+
+  describe("remove", () => {
+    it("should remove key from both storages", () => {
+      set("test-key", "value", false);
+      remove("test-key");
+      expect(localStorageMock.removeItem).toHaveBeenCalled();
+      expect(sessionStorageMock.removeItem).toHaveBeenCalled();
+
+      const value = get("test-key");
+      expect(value).toBeNull();
+    });
+  });
+
+  describe("clear", () => {
+    it("should clear both storages", () => {
+      set("key1", "value1", false);
+      set("key2", "value2", true);
+      clear();
+      expect(localStorageMock.clear).toHaveBeenCalled();
+      expect(sessionStorageMock.clear).toHaveBeenCalled();
+    });
+  });
+
+  describe("setKeyNS", () => {
+    it("should change key namespace", () => {
+      setKeyNS("custom-");
+      set("test-key", "value", false);
+      expect(localStorageMock.setItem).toHaveBeenCalledWith("custom-test-key", expect.any(String));
+    });
+
+    it("should not change namespace if empty string", () => {
+      setKeyNS("custom-");
+      setKeyNS("");
+      set("test-key", "value", false);
+      // Should still use the previous namespace
+      expect(localStorageMock.setItem).toHaveBeenCalledWith("custom-test-key", expect.any(String));
+    });
+
+    it("should not change namespace if not a string", () => {
+      setKeyNS("prefix-");
+      setKeyNS(123 as any);
+      set("k", "v", false);
+      expect(localStorageMock.setItem).toHaveBeenCalledWith("prefix-k", expect.any(String));
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should return null for non-existent key", () => {
+      const value = get("non-existent");
+      expect(value).toBeNull();
+    });
+
+    it("should handle invalid JSON gracefully", () => {
+      // Key must exist so get() proceeds to getItem and JSON.parse (hits catch)
+      set("corrupted-key", "x", false);
+      const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      localStorageMock.getItem = vi.fn(() => "invalid json");
+      const value = get("corrupted-key");
+      expect(value).toBeNull();
+      expect(errSpy).toHaveBeenCalled();
+      errSpy.mockRestore();
+    });
+
+    it("should return null when val has wrong format (no type/data)", () => {
+      // Key must exist so get() reaches getItem and the format check (lines 39-46)
+      set("bad-format", "x", false);
+      localStorageMock.getItem = vi.fn(() => JSON.stringify({ foo: "bar" }));
+      const value = get("bad-format");
+      expect(value).toBeNull();
+    });
+  });
+
+  describe("SSR / no window", () => {
+    it("get should return null when window is undefined", () => {
+      delete (global as any).window;
+      const value = get("any-key");
+      expect(value).toBeNull();
+    });
+
+    it("set should return false when window is undefined", () => {
+      delete (global as any).window;
+      const result = set("key", "value", false);
+      expect(result).toBe(false);
+    });
+
+    it("remove should no-op when window is undefined", () => {
+      delete (global as any).window;
+      expect(() => remove("key")).not.toThrow();
+    });
+
+    it("clear should no-op when window is undefined", () => {
+      delete (global as any).window;
+      expect(() => clear()).not.toThrow();
+    });
+
+    it("isKeyExist should return false when window is undefined", () => {
+      delete (global as any).window;
+      expect(isKeyExist("any-key")).toBe(false);
+    });
+  });
+
+  describe("set QUOTA exceeded", () => {
+    it("should clear and retry setItem when QUOTA error", () => {
+      const clearSpy = vi.spyOn(localStorageMock, "clear");
+      let callCount = 0;
+      localStorageMock.setItem = vi.fn((key: string, value: string) => {
+        callCount++;
+        if (callCount === 1) {
+          const err = new Error("QuotaExceededError") as Error & { name?: string };
+          err.name = "QuotaExceededError";
+          throw err;
+        }
+      });
+      const result = set("quota-key", "value", false);
+      expect(clearSpy).toHaveBeenCalled();
+      expect(localStorageMock.setItem).toHaveBeenCalledTimes(2);
+    });
+
+    it("should return false when setItem throws non-QUOTA error (catch branch)", () => {
+      localStorageMock.setItem = vi.fn(() => {
+        const err = new Error("SecurityError") as Error & { name?: string };
+        err.name = "SecurityError";
+        throw err;
+      });
+      const result = set("sec-key", "value", false);
+      expect(result).toBe(false);
+      expect(localStorageMock.setItem).toHaveBeenCalledTimes(1);
+      expect(localStorageMock.clear).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/__tests__/email.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from "vitest";
+import { maskEmail, isEmail } from "../email";
+
+describe("email utilities", () => {
+  describe("maskEmail", () => {
+    it("should mask email with username length >= 4", () => {
+      expect(maskEmail("alice@example.com")).toBe("al***@example.com");
+      // "testuser" has 8 chars, slice(0, -3) = "testu", so result is "testu***"
+      expect(maskEmail("testuser@example.com")).toBe("testu***@example.com");
+    });
+
+    it("should mask email with username length < 4", () => {
+      expect(maskEmail("abc@example.com")).toBe("abc*@example.com");
+      expect(maskEmail("ab@example.com")).toBe("ab**@example.com");
+      expect(maskEmail("a@example.com")).toBe("a***@example.com");
+    });
+
+    it("should return undefined for empty email", () => {
+      expect(maskEmail("")).toBeUndefined();
+    });
+
+    it("should return null for invalid email format", () => {
+      expect(maskEmail("invalid")).toBeNull();
+      expect(maskEmail("no-at-sign")).toBeNull();
+    });
+  });
+
+  describe("isEmail", () => {
+    it("should validate correct email addresses", () => {
+      expect(isEmail("test@example.com")).toBe(true);
+      expect(isEmail("user.name@example.co.uk")).toBe(true);
+      expect(isEmail("user+tag@example.com")).toBe(true);
+    });
+
+    it("should reject invalid email addresses", () => {
+      expect(isEmail("invalid")).toBe(false);
+      expect(isEmail("@example.com")).toBe(false);
+      expect(isEmail("test@")).toBe(false);
+      expect(isEmail("test@example")).toBe(false);
+      expect(isEmail("test @example.com")).toBe(false);
+    });
+  });
+});

package/src/__tests__/global-config.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from "vitest";
+import {
+  ChainTypeEnum,
+  SupportedChainTypes,
+  ProviderProtocol,
+  ProviderStandard,
+} from "../global-config";
+
+describe("global-config", () => {
+  describe("ChainTypeEnum", () => {
+    it("should have all chain types defined", () => {
+      expect(ChainTypeEnum.BITCOIN).toBe("bitcoin");
+      expect(ChainTypeEnum.DOGECOIN).toBe("dogecoin");
+      expect(ChainTypeEnum.EVM).toBe("evm");
+      expect(ChainTypeEnum.SOLANA).toBe("solana");
+      expect(ChainTypeEnum.SUI).toBe("sui");
+      expect(ChainTypeEnum.TON).toBe("ton");
+      expect(ChainTypeEnum.TRON).toBe("tron");
+      expect(ChainTypeEnum.COSMOS).toBe("cosmos");
+      expect(ChainTypeEnum.APTOS).toBe("aptos");
+    });
+  });
+
+  describe("SupportedChainTypes", () => {
+    it("should have configuration for DOGECOIN chain", () => {
+      const config = SupportedChainTypes[ChainTypeEnum.DOGECOIN];
+      expect(config.chainId).toBe("3");
+      expect(config.chainIndex).toBe(300);
+      expect(config.support).toBe(true);
+      expect(config.gasFee).toBe(0.5);
+      expect(config.dust).toBe(0.0001);
+    });
+
+    it("should have configuration for EVM chain", () => {
+      const config = SupportedChainTypes[ChainTypeEnum.EVM];
+      expect(config.chainId).toBe("1");
+      expect(config.chainIndex).toBe(100);
+      expect(config.support).toBe(true);
+      expect(config.gasFee).toBe(0.00001);
+      expect(config.dust).toBe(0);
+    });
+
+    it("should have configuration for SOLANA chain", () => {
+      const config = SupportedChainTypes[ChainTypeEnum.SOLANA];
+      expect(config.chainId).toBe("501");
+      expect(config.chainIndex).toBe(50100);
+      expect(config.support).toBe(true);
+      expect(config.gasFee).toBe(0.0001);
+      expect(config.dust).toBe(0);
+      expect(config.reserve).toBe(0.0009);
+    });
+
+    it("should have configuration for TRON chain", () => {
+      const config = SupportedChainTypes[ChainTypeEnum.TRON];
+      expect(config.chainId).toBe("19484");
+      expect(config.chainIndex).toBe(1948400);
+      expect(config.support).toBe(true);
+      expect(config.gasFee).toBe(0.5);
+      expect(config.dust).toBe(0);
+    });
+
+    it("should have configuration for BITCOIN chain", () => {
+      const config = SupportedChainTypes[ChainTypeEnum.BITCOIN];
+      expect(config.chainId).toBe("0");
+      expect(config.chainIndex).toBe(0);
+      expect(config.support).toBe(false);
+      expect(config.gasFee).toBe(0.00001);
+      expect(config.dust).toBe(0.0001);
+    });
+
+    it("should have configuration for unsupported chains", () => {
+      const unsupportedChains = [
+        ChainTypeEnum.SUI,
+        ChainTypeEnum.TON,
+        ChainTypeEnum.COSMOS,
+        ChainTypeEnum.APTOS,
+      ];
+      unsupportedChains.forEach((chainType) => {
+        const config = SupportedChainTypes[chainType];
+        expect(config.support).toBe(false);
+        expect(config.gasFee).toBe(0);
+        expect(config.dust).toBe(0);
+      });
+    });
+
+    it("should have all ChainTypeEnum in SupportedChainTypes", () => {
+      const allChainTypes = Object.values(ChainTypeEnum);
+      allChainTypes.forEach((chainType) => {
+        expect(SupportedChainTypes[chainType]).toBeDefined();
+      });
+    });
+  });
+
+  describe("ProviderProtocol", () => {
+    it("should have expected values", () => {
+      expect(ProviderProtocol.INJECT).toBe("inject");
+      expect(ProviderProtocol.DEEPLINK).toBe("deeplink");
+      expect(ProviderProtocol.WALLET_CONNECT).toBe("wallet-connect");
+    });
+  });
+
+  describe("ProviderStandard", () => {
+    it("should have expected values", () => {
+      expect(ProviderStandard.NORMAL).toBe("normal");
+      expect(ProviderStandard.EIP1193).toBe("eip1193");
+      expect(ProviderStandard.WALLET_STANDARD).toBe("wallet-standard");
+    });
+  });
+});

package/src/__tests__/index.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from "vitest";
+import {
+  cache,
+  CubeStages,
+  CubeOrgIds,
+  RelayOrigins,
+  TomoApiDomains,
+} from "../index";
+
+describe("index", () => {
+  it("should export cache module", () => {
+    expect(cache).toBeDefined();
+    expect(cache.get).toBeDefined();
+    expect(cache.set).toBeDefined();
+    expect(cache.remove).toBeDefined();
+    expect(cache.clear).toBeDefined();
+    expect(cache.setKeyNS).toBeDefined();
+  });
+
+  it("CubeStages should map stage to cube stage", () => {
+    expect(CubeStages.prod).toBe("prod");
+    expect(CubeStages.pre).toBe("prod");
+    expect(CubeStages.dev).toBe("gamma");
+  });
+
+  it("CubeOrgIds should have org ids per stage", () => {
+    expect(CubeOrgIds.prod).toMatch(/^Org#/);
+    expect(CubeOrgIds.pre).toMatch(/^Org#/);
+    expect(CubeOrgIds.dev).toMatch(/^Org#/);
+  });
+
+  it("RelayOrigins should have relay URLs", () => {
+    expect(RelayOrigins.prod).toBe("https://social-relay.tomo.inc");
+    expect(RelayOrigins.pre).toBe("https://social-relay.tomo.inc");
+    expect(RelayOrigins.dev).toBe("https://social-relay-dev.tomo.inc");
+  });
+
+  it("TomoApiDomains should have wallet API URLs", () => {
+    expect(TomoApiDomains.prod).toContain("tomo.inc");
+    expect(TomoApiDomains.pre).toContain("tomo.inc");
+    expect(TomoApiDomains.dev).toContain("tomo.inc");
+  });
+});

package/src/__tests__/password.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import { validatePassword } from "../password";
+
+describe("password validation", () => {
+  it("should validate password with letters and numbers", () => {
+    expect(validatePassword("password123")).toBe(true);
+    expect(validatePassword("Password123")).toBe(true);
+    expect(validatePassword("PASSWORD123")).toBe(true);
+  });
+
+  it("should reject password without letters", () => {
+    expect(validatePassword("12345678")).toBe(false);
+  });
+
+  it("should reject password without numbers", () => {
+    expect(validatePassword("password")).toBe(false);
+  });
+
+  it("should reject password too short", () => {
+    expect(validatePassword("pass123")).toBe(false);
+  });
+
+  it("should reject password too long", () => {
+    expect(validatePassword("a".repeat(33) + "123")).toBe(false);
+  });
+
+  it("should accept password with exactly 8 characters", () => {
+    expect(validatePassword("pass1234")).toBe(true);
+  });
+
+  it("should accept password with exactly 32 characters", () => {
+    expect(validatePassword("a".repeat(30) + "12")).toBe(true);
+  });
+});

package/src/__tests__/string.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect } from "vitest";
+import { stripHexPrefix, compareString, subs, getExplorerUrl, calcCtrLength } from "../string";
+
+describe("string utilities", () => {
+  describe("stripHexPrefix", () => {
+    it("should strip 0x prefix", () => {
+      expect(stripHexPrefix("0x123abc")).toBe("123abc");
+    });
+
+    it("should return original string if no prefix", () => {
+      expect(stripHexPrefix("123abc")).toBe("123abc");
+    });
+
+    it("should handle non-string input", () => {
+      expect(stripHexPrefix(123 as any)).toBe(123);
+    });
+  });
+
+  describe("compareString", () => {
+    it("should compare strings case-insensitively", () => {
+      expect(compareString("Hello", "hello")).toBe(true);
+      expect(compareString("WORLD", "world")).toBe(true);
+      expect(compareString("Test", "test")).toBe(true);
+    });
+
+    it("should return false for different strings", () => {
+      expect(compareString("Hello", "World")).toBe(false);
+    });
+  });
+
+  describe("subs", () => {
+    it("should substitute template variables", () => {
+      const template = "Hello {name}, you are {age} years old";
+      const data = { name: "Alice", age: 30 };
+      const result = subs(template, data);
+      expect(result).toBe("Hello Alice, you are 30 years old");
+    });
+
+    it("should handle array of objects", () => {
+      const template = "{name}: {value}";
+      const data = [
+        { name: "key1", value: "value1" },
+        { name: "key2", value: "value2" },
+      ];
+      const result = subs(template, data);
+      expect(result).toBe("key1: value1key2: value2");
+    });
+
+    it("should handle escaped braces", () => {
+      // In the string "\\{literal\\}", the backslashes escape the braces
+      // The regex /\\?\{([^}]+)\}/g matches \{literal\}, and since match.charAt(0) == "\\",
+      // it returns match.slice(1) which is "{literal\}"
+      const template = "\\{literal\\} {name}";
+      const data = { name: "Alice" };
+      const result = subs(template, data);
+      // The actual behavior: escaped braces become "{literal\}" (backslash is preserved)
+      expect(result).toBe("{literal\\} Alice");
+    });
+
+    it("should handle missing variables", () => {
+      const template = "Hello {name}, {missing}";
+      const data = { name: "Alice" };
+      const result = subs(template, data);
+      expect(result).toBe("Hello Alice, ");
+    });
+
+    it("should use custom regexp when provided", () => {
+      const template = "Hello {{name}}";
+      const data = { name: "Bob" };
+      const result = subs(template, data, /\{\{([^}]+)\}\}/g);
+      expect(result).toBe("Hello Bob");
+    });
+  });
+
+  describe("getExplorerUrl", () => {
+    it("should return correct explorer URL for Ethereum", () => {
+      const url = getExplorerUrl(100, { txId: "0x123" });
+      expect(url).toBe("https://etherscan.io/tx/0x123");
+    });
+
+    it("should return correct explorer URL for Solana", () => {
+      const url = getExplorerUrl(50100, { txId: "abc123" });
+      expect(url).toBe("https://solscan.io/tx/abc123");
+    });
+
+    it("should return correct explorer URL for BSC", () => {
+      const url = getExplorerUrl(5600, { txId: "0x456" });
+      expect(url).toBe("https://bscscan.com/tx/0x456");
+    });
+
+    it("should throw error for unsupported chain", () => {
+      expect(() => getExplorerUrl(99999, { txId: "0x123" })).toThrow();
+    });
+
+    it("should throw when chainIndex has no explorer tpl", () => {
+      expect(() => getExplorerUrl(0, { txId: "0x123" })).toThrow("chainIndex 0 tpl not found");
+    });
+  });
+
+  describe("calcCtrLength", () => {
+    it("should calculate length for English text", () => {
+      const result = calcCtrLength("Hello");
+      expect(result.len).toBe(5);
+      expect(result.originLen).toBe(5);
+    });
+
+    it("should calculate length for Chinese text", () => {
+      const result = calcCtrLength("你好");
+      expect(result.len).toBe(4); // Chinese characters count as 2
+      expect(result.originLen).toBe(2);
+    });
+
+    it("should handle mixed text", () => {
+      const result = calcCtrLength("Hello你好");
+      expect(result.len).toBe(9); // 5 + 4
+      expect(result.originLen).toBe(7); // 5 + 2
+    });
+
+    it("should trim whitespace", () => {
+      const result = calcCtrLength("  Hello  ");
+      expect(result.len).toBe(5);
+      expect(result.originLen).toBe(5);
+    });
+  });
+});

package/src/cache.ts

@@ -117,4 +117,4 @@ function setKeyNS(NS: string) {
   }
 }
 
-export { clear, get, remove, set, setKeyNS };
+export { clear, get, isKeyExist, remove, set, setKeyNS };

package/src/index.ts

@@ -7,27 +7,31 @@ export * from "./global-config";
 export * from "./password";
 export * from "./string";
 
-export type TomoStage = "prod" | "pre" | "dev";
+export type TomoStage = "prod" | "pre" | "dev" | "prod-dogeos";
 export type CubeStage = "gamma" | "prod";
 export const CubeStages = {
+  "prod-dogeos": "prod",
   prod: "prod",
   pre: "prod",
   dev: "gamma",
 };
 
 export const CubeOrgIds = {
+  "prod-dogeos": "Org#49944bce-9daf-423f-a982-269f6d0d301b",
   prod: "Org#49944bce-9daf-423f-a982-269f6d0d301b",
   pre: "Org#71c13f6d-b992-4660-874d-2ae0fadc789f",
   dev: "Org#3d07a75a-1188-4bd0-acfa-671a198b83eb",
 };
 
 export const RelayOrigins = {
+  "prod-dogeos": "https://social-relay.tomo.inc",
   prod: "https://social-relay.tomo.inc",
   pre: "https://social-relay.tomo.inc",
   dev: "https://social-relay-dev.tomo.inc",
 };
 
 export const TomoApiDomains = {
+  "prod-dogeos": "https://mydoge-wallet.tomo.inc",
   prod: "https://wallet-pro.tomo.inc",
   pre: "https://wallet-pre-wlfi.tomo.inc",
   dev: "https://wallet-test.tomo.inc",

package/vitest.config.ts

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