@tomo-inc/chains-service 0.0.23 → 0.0.25

package/src/__tests__/wallet.test.ts

@@ -0,0 +1,350 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { TomoWallet } from "../wallet";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
+import { SIGN_CONFIG } from "../api/__tests__/config";
+
+// Mock tomoPublicApiService
+vi.mock("../api", () => {
+  return {
+    tomoPublicApiService: vi.fn(() => ({
+      tokenAPIs: {},
+      transactionAPIs: {},
+      networkAPIs: {},
+    })),
+  };
+});
+
+// Mock BaseService after mocking api
+vi.mock("../base/service", async () => {
+  const actual = await vi.importActual("../base/service");
+  return {
+    ...actual,
+    BaseService: class BaseService {
+      public networks: any;
+      public tokens: any;
+      public transactions: any;
+      public isDappConnected: boolean;
+      public approveParams: any;
+      public accountInfo: any;
+
+      constructor(_tomoAppInfo: any, _accountInfo?: any) {
+        this.networks = {
+          getNetworks: vi.fn(),
+          setChainType: vi.fn(),
+          getNetworkByChainId: vi.fn(),
+          getNetworkByChainIndex: vi.fn(),
+        };
+        this.transactions = {
+          getTransactions: vi.fn(),
+        };
+        this.tokens = {};
+        this.isDappConnected = false;
+        this.approveParams = null;
+        this.accountInfo = _accountInfo || null;
+      }
+    },
+  };
+});
+
+describe("TomoWallet", () => {
+  let wallet: TomoWallet;
+  const mockTomoAppInfo = {
+    tomoStage: "dev" as const,
+    tomoClientId: SIGN_CONFIG.clientId || "",
+  };
+  const walletId = "test-wallet-id";
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    wallet = new TomoWallet(walletId, mockTomoAppInfo);
+  });
+
+  describe("constructor", () => {
+    it("should create a new TomoWallet instance", () => {
+      expect(wallet).toBeInstanceOf(TomoWallet);
+    });
+  });
+
+  describe("getInstance", () => {
+    it("should return a new TomoWallet instance", () => {
+      const instance = wallet.getInstance(walletId, mockTomoAppInfo);
+      expect(instance).toBeInstanceOf(TomoWallet);
+    });
+  });
+
+  describe("supportedChains", () => {
+    it("should return supported chains for a specific chain type", async () => {
+      const mockNetworks = [
+        { chainId: 1, name: "Ethereum", platformType: "EVM" },
+        { chainId: 56, name: "BSC", platformType: "EVM" },
+      ];
+      (wallet as any).networks.getNetworks = vi.fn().mockResolvedValue(mockNetworks);
+
+      const result = await wallet.supportedChains(ChainTypeEnum.EVM);
+      expect(result).toEqual(mockNetworks);
+      expect((wallet as any).networks.getNetworks).toHaveBeenCalledWith(ChainTypeEnum.EVM);
+    });
+
+    it("should return all chains when chainType is empty", async () => {
+      const mockNetworks = [
+        { chainId: 1, name: "Ethereum", platformType: "EVM" },
+        { chainId: 501, name: "Solana", platformType: "SOLANA" },
+      ];
+      (wallet as any).networks.getNetworks = vi.fn().mockResolvedValue(mockNetworks);
+
+      const result = await wallet.supportedChains();
+      expect(result).toEqual(mockNetworks);
+      expect((wallet as any).networks.getNetworks).toHaveBeenCalledWith("");
+    });
+  });
+
+  describe("getChainInfo", () => {
+    it("should return chain info by chainId", async () => {
+      const mockNetwork = { chainId: 1, name: "Ethereum", platformType: "EVM" };
+      (wallet as any).networks.setChainType = vi.fn();
+      (wallet as any).networks.getNetworkByChainId = vi.fn().mockResolvedValue(mockNetwork);
+
+      const result = await wallet.getChainInfo(ChainTypeEnum.EVM, "1");
+      expect(result).toEqual(mockNetwork);
+      expect((wallet as any).networks.setChainType).toHaveBeenCalledWith(ChainTypeEnum.EVM);
+      expect((wallet as any).networks.getNetworkByChainId).toHaveBeenCalledWith("1");
+    });
+  });
+
+  describe("isChainSupported", () => {
+    it("should return true if chain is supported", async () => {
+      const mockNetwork = { chainId: 1, name: "Ethereum" };
+      (wallet as any).networks.setChainType = vi.fn();
+      (wallet as any).networks.getNetworkByChainId = vi.fn().mockResolvedValue(mockNetwork);
+
+      const result = await wallet.isChainSupported(ChainTypeEnum.EVM, "1");
+      expect(result).toBe(true);
+    });
+
+    it("should return false if chain is not found", async () => {
+      (wallet as any).networks.setChainType = vi.fn();
+      (wallet as any).networks.getNetworkByChainId = vi.fn().mockResolvedValue(null);
+
+      const result = await wallet.isChainSupported(ChainTypeEnum.EVM, "999");
+      expect(result).toBe(false);
+    });
+
+    it("should return false if chainId is missing", async () => {
+      const mockNetwork = { name: "Ethereum" }; // no chainId
+      (wallet as any).networks.setChainType = vi.fn();
+      (wallet as any).networks.getNetworkByChainId = vi.fn().mockResolvedValue(mockNetwork);
+
+      const result = await wallet.isChainSupported(ChainTypeEnum.EVM, "1");
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("getTransactions", () => {
+    it("should get transactions successfully", async () => {
+      const mockTransactionList = [
+        {
+          chainIndex: 100,
+          txHash: "0x123",
+          tokenInfo: {},
+          txTime: 1234567890,
+        },
+      ];
+      const mockChainInfo = {
+        chainId: 1,
+        name: "Ethereum",
+        icon: "icon.png",
+        platformType: "EVM",
+        nativeCurrency: { symbol: "ETH", decimals: 18 },
+      };
+
+      (wallet as any).networks.getNetworkByChainId = vi.fn().mockResolvedValue(mockChainInfo);
+      (wallet as any).networks.getNetworkByChainIndex = vi.fn().mockResolvedValue(mockChainInfo);
+      (wallet as any).transactions.getTransactions = vi.fn().mockResolvedValue({
+        cursor: "next-cursor",
+        transactionList: mockTransactionList,
+      });
+
+      const result = await wallet.getTransactions({
+        chainId: "1",
+        pageLimit: 20,
+      });
+
+      expect(result.cursor).toBe("next-cursor");
+      expect(result.transactionList).toHaveLength(1);
+      expect(result.transactionList[0]).toHaveProperty("chainType");
+      expect(result.transactionList[0]).toHaveProperty("chainInfo");
+      expect(result.transactionList[0]).toHaveProperty("txHash");
+    });
+
+    it("should throw error when walletId is missing", async () => {
+      const walletWithoutId = new TomoWallet("", mockTomoAppInfo);
+      await expect(
+        walletWithoutId.getTransactions({
+          pageLimit: 20,
+        }),
+      ).rejects.toThrow("walletId is required");
+    });
+
+    it("should handle transactions with typeList", async () => {
+      const mockTransactionList = [
+        {
+          chainIndex: 100,
+          txHash: "0x123",
+          tokenInfo: {},
+          txTime: 1234567890,
+        },
+      ];
+      const mockChainInfo = {
+        chainId: 1,
+        name: "Ethereum",
+        icon: "icon.png",
+        platformType: "EVM",
+        nativeCurrency: { symbol: "ETH", decimals: 18 },
+      };
+
+      (wallet as any).networks.getNetworkByChainId = vi.fn().mockResolvedValue(mockChainInfo);
+      (wallet as any).networks.getNetworkByChainIndex = vi.fn().mockResolvedValue(mockChainInfo);
+      (wallet as any).transactions.getTransactions = vi.fn().mockResolvedValue({
+        cursor: "",
+        transactionList: mockTransactionList,
+      });
+
+      const result = await wallet.getTransactions({
+        typeList: ["send", "receive"],
+        pageLimit: 20,
+      });
+
+      expect((wallet as any).transactions.getTransactions).toHaveBeenCalledWith(
+        expect.objectContaining({
+          typeList: "send,receive",
+        }),
+      );
+    });
+
+    it("should handle error in getTransactions", async () => {
+      const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      (wallet as any).transactions.getTransactions = vi.fn().mockRejectedValue(new Error("API Error"));
+
+      await expect(
+        wallet.getTransactions({
+          pageLimit: 20,
+        }),
+      ).rejects.toThrow();
+
+      expect(consoleErrorSpy).toHaveBeenCalled();
+      consoleErrorSpy.mockRestore();
+    });
+
+    it("should handle transactions with cursor", async () => {
+      const mockTransactionList = [
+        {
+          chainIndex: 100,
+          txHash: "0x123",
+          tokenInfo: {},
+          txTime: 1234567890,
+        },
+      ];
+      const mockChainInfo = {
+        chainId: 1,
+        name: "Ethereum",
+        icon: "icon.png",
+        platformType: "EVM",
+        nativeCurrency: { symbol: "ETH", decimals: 18 },
+      };
+
+      (wallet as any).networks.getNetworkByChainId = vi.fn().mockResolvedValue(mockChainInfo);
+      (wallet as any).networks.getNetworkByChainIndex = vi.fn().mockResolvedValue(mockChainInfo);
+      (wallet as any).transactions.getTransactions = vi.fn().mockResolvedValue({
+        cursor: "next-page",
+        transactionList: mockTransactionList,
+      });
+
+      const result = await wallet.getTransactions({
+        cursor: "prev-cursor",
+        pageLimit: 20,
+      });
+
+      expect((wallet as any).transactions.getTransactions).toHaveBeenCalledWith(
+        expect.objectContaining({
+          cursor: "prev-cursor",
+        }),
+      );
+      expect(result.cursor).toBe("next-page");
+    });
+
+    it("should handle transactions with tokenAddress", async () => {
+      const mockTransactionList = [
+        {
+          chainIndex: 100,
+          txHash: "0x123",
+          tokenInfo: {},
+          txTime: 1234567890,
+        },
+      ];
+      const mockChainInfo = {
+        chainId: 1,
+        name: "Ethereum",
+        icon: "icon.png",
+        platformType: "EVM",
+        nativeCurrency: { symbol: "ETH", decimals: 18 },
+        chainIndex: 100,
+      };
+
+      (wallet as any).networks.getNetworkByChainId = vi.fn().mockResolvedValue(mockChainInfo);
+      (wallet as any).networks.getNetworkByChainIndex = vi.fn().mockResolvedValue(mockChainInfo);
+      (wallet as any).transactions.getTransactions = vi.fn().mockResolvedValue({
+        cursor: "",
+        transactionList: mockTransactionList,
+      });
+
+      const result = await wallet.getTransactions({
+        tokenAddress: "0xtoken123",
+        chainId: "1",
+        pageLimit: 20,
+      });
+
+      expect((wallet as any).transactions.getTransactions).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tokenAddress: "0xtoken123",
+          chainIndex: 100,
+        }),
+      );
+      expect(result.transactionList).toHaveLength(1);
+    });
+
+    it("should handle getTransactions without chainId", async () => {
+      const mockTransactionList = [
+        {
+          chainIndex: 100,
+          txHash: "0x123",
+          tokenInfo: {},
+          txTime: 1234567890,
+        },
+      ];
+      const mockChainInfo = {
+        chainId: 1,
+        name: "Ethereum",
+        icon: "icon.png",
+        platformType: "EVM",
+        nativeCurrency: { symbol: "ETH", decimals: 18 },
+      };
+
+      (wallet as any).networks.getNetworkByChainIndex = vi.fn().mockResolvedValue(mockChainInfo);
+      (wallet as any).transactions.getTransactions = vi.fn().mockResolvedValue({
+        cursor: "",
+        transactionList: mockTransactionList,
+      });
+
+      const result = await wallet.getTransactions({
+        pageLimit: 20,
+      });
+
+      expect((wallet as any).transactions.getTransactions).toHaveBeenCalledWith(
+        expect.not.objectContaining({
+          chainIndex: expect.anything(),
+        }),
+      );
+      expect(result.transactionList).toHaveLength(1);
+    });
+  });
+});

package/src/api/__tests__/base.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { BasePublicService, BasePrivateService } from "../base";
+import { CONFIG, SIGN_CONFIG } from "./config";
+
+const requestUseHandlers: ((params: any) => any)[] = [];
+
+vi.mock("axios", () => ({
+  default: {
+    create: vi.fn(() => {
+      const useFn = vi.fn((handler: (params: any) => any) => {
+        requestUseHandlers.push(handler);
+      });
+      return {
+        interceptors: {
+          request: { use: useFn },
+          response: { use: vi.fn() },
+        },
+      };
+    }),
+  },
+}));
+
+const signRequestMock = vi.fn((params: any) => params);
+vi.mock("../utils", () => ({
+  signRequest: (...args: any[]) => signRequestMock(...args),
+}));
+
+describe("BasePublicService", () => {
+  const mockTomoAppInfo = {
+    tomoStage: "dev" as const,
+    tomoClientId: SIGN_CONFIG.clientId || "",
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    requestUseHandlers.length = 0;
+  });
+
+  describe("constructor", () => {
+    it("should create BasePublicService instance", () => {
+      const service = new BasePublicService(CONFIG, mockTomoAppInfo);
+      expect(service).toBeInstanceOf(BasePublicService);
+      expect(service.tokenApi).toBeDefined();
+      expect(service.txApi).toBeDefined();
+      expect(service.walletApi).toBeDefined();
+    });
+
+    it("should set up interceptors for all APIs", () => {
+      const service = new BasePublicService(CONFIG, mockTomoAppInfo);
+      expect(service.tokenApi.interceptors.request.use).toHaveBeenCalled();
+      expect(service.txApi.interceptors.request.use).toHaveBeenCalled();
+      expect(service.walletApi.interceptors.request.use).toHaveBeenCalled();
+    });
+
+    it("should run request interceptor and set baseURL per api", () => {
+      new BasePublicService(CONFIG, mockTomoAppInfo);
+      expect(requestUseHandlers.length).toBe(3);
+      const bases = [CONFIG.tokenBaseUrl, CONFIG.txBaseUrl, CONFIG.walletBaseUrl];
+      requestUseHandlers.forEach((handler, i) => {
+        const params = { method: "GET", url: "/test" };
+        const result = handler(params);
+        expect(params.baseURL).toBe(bases[i]);
+        expect(signRequestMock).toHaveBeenCalledWith(params, mockTomoAppInfo.tomoClientId, mockTomoAppInfo);
+        expect(result).toBe(params);
+      });
+    });
+
+    it("getSignConfig should return tomoAppInfo", () => {
+      const service = new BasePublicService(CONFIG, mockTomoAppInfo);
+      const config = (service as any).getSignConfig();
+      expect(config).toBe(mockTomoAppInfo);
+    });
+  });
+});
+
+describe("BasePrivateService", () => {
+  const mockTomoAppInfo = {
+    tomoStage: "dev" as const,
+    tomoClientId: SIGN_CONFIG.clientId || "",
+    jwtToken: "test-jwt-token",
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    requestUseHandlers.length = 0;
+  });
+
+  describe("constructor", () => {
+    it("should create BasePrivateService instance", () => {
+      const service = new BasePrivateService(
+        {
+          userBaseUrl: CONFIG.userBaseUrl,
+        },
+        mockTomoAppInfo,
+      );
+      expect(service).toBeInstanceOf(BasePrivateService);
+      expect(service.userApi).toBeDefined();
+    });
+
+    it("should set up interceptors for userApi", () => {
+      const service = new BasePrivateService(
+        {
+          userBaseUrl: CONFIG.userBaseUrl,
+        },
+        mockTomoAppInfo,
+      );
+      expect(service.userApi.interceptors.request.use).toHaveBeenCalled();
+    });
+
+    it("should run request interceptor and set baseURL for userApi", () => {
+      requestUseHandlers.length = 0;
+      const privateConfig = { userBaseUrl: CONFIG.userBaseUrl };
+      new BasePrivateService(privateConfig, mockTomoAppInfo);
+      expect(requestUseHandlers.length).toBe(1);
+      const params = { method: "POST", url: "/api/user" };
+      requestUseHandlers[0](params);
+      expect(params.baseURL).toBe(privateConfig.userBaseUrl);
+      expect(signRequestMock).toHaveBeenCalledWith(params, mockTomoAppInfo.tomoClientId, mockTomoAppInfo.jwtToken);
+    });
+
+    it("should use empty jwtToken when not provided", () => {
+      const service = new BasePrivateService(
+        {
+          userBaseUrl: CONFIG.userBaseUrl,
+        },
+        {
+          tomoStage: "dev" as const,
+          tomoClientId: SIGN_CONFIG.clientId || "",
+        },
+      );
+      expect(service.getJwtToken()).toBe("");
+    });
+  });
+
+  describe("getJwtToken", () => {
+    it("should return jwtToken", () => {
+      const service = new BasePrivateService(
+        {
+          userBaseUrl: CONFIG.userBaseUrl,
+        },
+        mockTomoAppInfo,
+      );
+      expect(service.getJwtToken()).toBe("test-jwt-token");
+    });
+  });
+});

package/src/api/__tests__/index.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { tomoPublicApiService, tomoPrivateApiService } from "../index";
+import { CONFIG, SIGN_CONFIG } from "./config";
+
+vi.mock("../network", () => ({
+  NetworkAPIs: { getInstance: vi.fn(() => ({})) },
+}));
+vi.mock("../token", () => ({
+  TokenAPIs: { getInstance: vi.fn(() => ({})) },
+}));
+vi.mock("../transaction", () => ({
+  TransactionAPIs: { getInstance: vi.fn(() => ({})) },
+}));
+vi.mock("../wallet", () => ({
+  WalletAPIs: { getInstance: vi.fn(() => ({})) },
+}));
+vi.mock("../user", () => ({
+  UserAPIs: { getInstance: vi.fn(() => ({})) },
+}));
+
+describe("api index", () => {
+  const publicTomoAppInfo = {
+    tomoStage: "dev" as const,
+    tomoClientId: SIGN_CONFIG.clientId || "",
+  };
+  const privateTomoAppInfo = {
+    ...publicTomoAppInfo,
+    jwtToken: "test-jwt",
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("tomoPublicApiService should return tokenAPIs, transactionAPIs, networkAPIs, walletAPIs", () => {
+    const result = tomoPublicApiService(CONFIG, publicTomoAppInfo);
+    expect(result).toHaveProperty("tokenAPIs");
+    expect(result).toHaveProperty("transactionAPIs");
+    expect(result).toHaveProperty("networkAPIs");
+    expect(result).toHaveProperty("walletAPIs");
+  });
+
+  it("tomoPrivateApiService should return userAPIs", () => {
+    const result = tomoPrivateApiService(
+      { userBaseUrl: CONFIG.userBaseUrl },
+      privateTomoAppInfo,
+    );
+    expect(result).toHaveProperty("userAPIs");
+    expect(result.userAPIs).toBeDefined();
+  });
+});

package/src/api/__tests__/network.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { NetworkAPIs } from "../network";
+import { ChainTypeEnum, SupportedChainTypes } from "@tomo-inc/wallet-utils";
+import { CONFIG, SIGN_CONFIG } from "./config";
+import * as walletUtils from "@tomo-inc/wallet-utils";
+
+// Mock cache
+vi.mock("@tomo-inc/wallet-utils", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@tomo-inc/wallet-utils")>();
+  return {
+    ...actual,
+    cache: {
+      get: vi.fn(),
+      set: vi.fn(),
+    },
+  };
+});
+
+describe("NetworkAPIs", () => {
+  const mockTomoAppInfo = {
+    tomoStage: "dev" as const,
+    tomoClientId: SIGN_CONFIG.clientId || "",
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Reset singleton instance
+    (NetworkAPIs as any).instance = undefined;
+  });
+
+  describe("getInstance", () => {
+    it("should return singleton instance", () => {
+      const instance1 = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      const instance2 = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      expect(instance1).toBe(instance2);
+    });
+  });
+
+  describe("getCacheId", () => {
+    it("should return cache id for chain type", () => {
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      const cacheId = instance.getCacheId(ChainTypeEnum.EVM);
+      expect(cacheId).toBe(`tomo-${ChainTypeEnum.EVM}-currentChainId`);
+    });
+
+    it("should return cache id for empty chain type", () => {
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      const cacheId = instance.getCacheId("");
+      expect(cacheId).toBe("tomo--currentChainId");
+    });
+  });
+
+  describe("getAllNetworks", () => {
+    it("should return all networks when chainType is empty", () => {
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      const networks = instance.getAllNetworks("");
+      expect(networks.length).toBeGreaterThan(0);
+    });
+
+    it("should return filtered networks for specific chain type", () => {
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      const networks = instance.getAllNetworks(ChainTypeEnum.EVM);
+      expect(networks.every((n) => n.platformType === "EVM")).toBe(true);
+    });
+
+    it("should return filtered networks for DOGE chain type", () => {
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      const networks = instance.getAllNetworks(ChainTypeEnum.DOGECOIN);
+      expect(networks.every((n) => n.platformType === "DOGE")).toBe(true);
+    });
+  });
+
+  describe("getCurrentNetwork", () => {
+    it("should return cached chainId if available", async () => {
+      const cache = vi.mocked(walletUtils.cache);
+      cache.get.mockReturnValue("56");
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      const chainId = await instance.getCurrentNetwork(ChainTypeEnum.EVM);
+      expect(chainId).toBe("56");
+    });
+
+    it("should return default chainId from SupportedChainTypes if cache is empty", async () => {
+      const cache = vi.mocked(walletUtils.cache);
+      cache.get.mockReturnValue(null);
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      const chainId = await instance.getCurrentNetwork(ChainTypeEnum.EVM);
+      expect(chainId).toBe(SupportedChainTypes[ChainTypeEnum.EVM]?.chainId || "1");
+    });
+
+    it("should throw error for unsupported chain type", async () => {
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      await expect(instance.getCurrentNetwork("UNSUPPORTED" as ChainTypeEnum)).rejects.toThrow(
+        "Chain UNSUPPORTED is not supported",
+      );
+    });
+  });
+
+  describe("setCurrentNetwork", () => {
+    it("should set current network and cache it", async () => {
+      const cache = vi.mocked(walletUtils.cache);
+      cache.set.mockImplementation(() => true);
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      await instance.setCurrentNetwork(ChainTypeEnum.EVM, "56");
+      expect(instance.currentChainId).toBe("56");
+      expect(cache.set).toHaveBeenCalled();
+    });
+
+    it("should set current network for empty chainType", async () => {
+      const cache = vi.mocked(walletUtils.cache);
+      cache.set.mockImplementation(() => true);
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      await instance.setCurrentNetwork("", "1");
+      expect(instance.currentChainId).toBe("1");
+    });
+
+    it("should throw error for unsupported chain type", async () => {
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      await expect(instance.setCurrentNetwork("UNSUPPORTED" as ChainTypeEnum, "1")).rejects.toThrow(
+        "Chain UNSUPPORTED is not supported",
+      );
+    });
+  });
+
+  describe("getNetworkByChainId", () => {
+    it("should return network by chainId", () => {
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      const network = instance.getNetworkByChainId("1");
+      expect(network).toBeDefined();
+      expect(network?.chainId).toBe(1);
+    });
+
+    it("should return undefined if chainId not found", () => {
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      const network = instance.getNetworkByChainId("99999");
+      expect(network).toBeUndefined();
+    });
+  });
+
+  describe("getNetworkByChainIndex", () => {
+    it("should return network by chainIndex", () => {
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      const network = instance.getNetworkByChainIndex(100);
+      expect(network).toBeDefined();
+      expect(network?.chainIndex).toBe(100);
+    });
+
+    it("should return undefined if chainIndex not found", () => {
+      const instance = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+      const network = instance.getNetworkByChainIndex(99999);
+      expect(network).toBeUndefined();
+    });
+  });
+});