@tomo-inc/chains-service 0.0.22 → 0.0.24

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

@@ -1,6 +1,31 @@
 import { CONFIG, jwtToken } from "./config";
 import { UserAPIs } from "../user";
 import { beforeEach, describe, it, expect, vi, afterEach } from "vitest";
+import axios from "axios";
+
+// Mock axios
+vi.mock("axios", () => ({
+  default: {
+    create: vi.fn(() => ({
+      post: vi.fn(),
+      get: vi.fn(),
+      interceptors: {
+        request: { use: vi.fn() },
+        response: { use: vi.fn() },
+      },
+    })),
+  },
+}));
+
+// Mock signature utility
+vi.mock("../utils", () => ({
+  signature: {
+    generateCubeSignature: vi.fn().mockResolvedValue({
+      timestamp: "1234567890",
+      signature: "test-signature",
+    }),
+  },
+}));
 
 describe("api", () => {
   let service: UserAPIs;
@@ -12,7 +37,8 @@ describe("api", () => {
   };
 
   beforeEach(() => {
-    service = UserAPIs.getInstance(CONFIG, jwtToken);
+    // Reset instance before each test
+    (UserAPIs as any).instance = undefined;
     vi.clearAllMocks();
   });
 
@@ -22,13 +48,57 @@ describe("api", () => {
 
   describe("user", () => {
     it("getUserInfo", async () => {
+      const mockResponse = {
+        data: {
+          code: "10000",
+          data: {
+            user: {
+              userID: "test-user-id",
+              nickname: "Test User",
+            },
+            account: {},
+          },
+        },
+      };
+      const mockPost = vi.fn().mockResolvedValue(mockResponse);
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: {
+          request: { use: vi.fn() },
+          response: { use: vi.fn() },
+        },
+      } as any);
+
+      // Create service instance after mock is set
+      service = UserAPIs.getInstance(CONFIG, jwtToken);
       const result = await service.getUserInfo();
       console.log("getUserInfo", result);
 
       expect(typeof result.success).toBe("boolean");
       expect(typeof result.data).toBe("object");
-      expect(typeof result.data?.userID).toBe("string");
-      expect(typeof result.data?.nickname).toBe("string");
+      expect(result.data).toHaveProperty("user");
+      expect(result.data?.user).toHaveProperty("userID");
+      expect(result.data?.user).toHaveProperty("nickname");
+    });
+
+    it("getUserInfo should set success false when code is not 10000", async () => {
+      const mockPost = vi.fn().mockResolvedValue({
+        data: {
+          code: "10001",
+          message: "Unauthorized",
+          data: null,
+        },
+      });
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: { request: { use: vi.fn() }, response: { use: vi.fn() } },
+      } as any);
+      service = UserAPIs.getInstance(CONFIG, jwtToken);
+      const result = await service.getUserInfo();
+      expect(result.success).toBe(false);
+      expect(result.message).toBe("Unauthorized");
     });
 
     it("updateUserInfo", async () => {
@@ -38,6 +108,28 @@ describe("api", () => {
         username: `${params.username}_${r}`,
       };
 
+      const mockResponse = {
+        data: {
+          code: "10000",
+          data: {
+            userID: "test-user-id",
+            nickname: userInfo.nickname,
+            username: userInfo.username,
+          },
+        },
+      };
+      const mockPost = vi.fn().mockResolvedValue(mockResponse);
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: {
+          request: { use: vi.fn() },
+          response: { use: vi.fn() },
+        },
+      } as any);
+
+      // Create service instance after mock is set
+      service = UserAPIs.getInstance(CONFIG, jwtToken);
       const result = await service.updateUserInfo(userInfo);
       console.log("updateUserInfo", result);
 
@@ -84,6 +176,29 @@ describe("api", () => {
     // });
 
     it("getUserWallet", async () => {
+      const mockResponse = {
+        data: {
+          success: true,
+          data: {
+            id: "test-wallet-id",
+            bitcoinP2shPubKeyMain: "test-pubkey",
+            deleted: false,
+            solanaAddress: "test-solana-address",
+          },
+        },
+      };
+      const mockPost = vi.fn().mockResolvedValue(mockResponse);
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: {
+          request: { use: vi.fn() },
+          response: { use: vi.fn() },
+        },
+      } as any);
+
+      // Create service instance after mock is set
+      service = UserAPIs.getInstance(CONFIG, jwtToken);
       const result = await service.getUserWallet();
       console.log("getUserWallet", result);
 
@@ -96,10 +211,129 @@ describe("api", () => {
     });
 
     it("isExistEmail", async () => {
+      const mockResponse = {
+        data: {
+          code: "10000",
+          data: {},
+        },
+      };
+      const mockPost = vi.fn().mockResolvedValue(mockResponse);
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: {
+          request: { use: vi.fn() },
+          response: { use: vi.fn() },
+        },
+      } as any);
+
+      // Create service instance after mock is set
+      service = UserAPIs.getInstance(CONFIG, jwtToken);
       const result = await service.isExistEmail(params.email);
       console.log("isExistEmail", result);
 
       expect(typeof result).toBe("object");
     });
+
+    it("should throw error when updateUserInfo is called without userInfo", async () => {
+      service = UserAPIs.getInstance(CONFIG, jwtToken);
+      await expect(service.updateUserInfo(null as any)).rejects.toThrow("User info is required");
+    });
+
+    it("sendExportSeedPhraseEmail", async () => {
+      const mockResponse = {
+        data: {
+          code: "10000",
+          data: {},
+        },
+      };
+      const mockPost = vi.fn().mockResolvedValue(mockResponse);
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: {
+          request: { use: vi.fn() },
+          response: { use: vi.fn() },
+        },
+      } as any);
+
+      service = UserAPIs.getInstance(CONFIG, jwtToken);
+      const result = await service.sendExportSeedPhraseEmail(params.exportTime);
+      expect(mockPost).toHaveBeenCalled();
+      expect(result).toBeDefined();
+    });
+
+    it("sendCancelExportSeedPhraseEmail", async () => {
+      const mockResponse = {
+        data: {
+          code: "10000",
+          data: {},
+        },
+      };
+      const mockPost = vi.fn().mockResolvedValue(mockResponse);
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: {
+          request: { use: vi.fn() },
+          response: { use: vi.fn() },
+        },
+      } as any);
+
+      service = UserAPIs.getInstance(CONFIG, jwtToken);
+      const result = await service.sendCancelExportSeedPhraseEmail();
+      expect(mockPost).toHaveBeenCalled();
+      expect(result).toBeDefined();
+    });
+
+    it("sendChangeDeviceEmail", async () => {
+      const mockResponse = {
+        data: {
+          code: "10000",
+          data: {},
+        },
+      };
+      const mockPost = vi.fn().mockResolvedValue(mockResponse);
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: {
+          request: { use: vi.fn() },
+          response: { use: vi.fn() },
+        },
+      } as any);
+
+      service = UserAPIs.getInstance(CONFIG, jwtToken);
+      const result = await service.sendChangeDeviceEmail(params.exportTime);
+      expect(mockPost).toHaveBeenCalled();
+      expect(result).toBeDefined();
+    });
+
+    it("addUserToCube", async () => {
+      const mockResponse = {
+        data: {
+          code: "10000",
+          data: {},
+        },
+      };
+      const mockPost = vi.fn().mockResolvedValue(mockResponse);
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: {
+          request: { use: vi.fn() },
+          response: { use: vi.fn() },
+        },
+      } as any);
+
+      service = UserAPIs.getInstance(CONFIG, jwtToken);
+      const req = {
+        iss: "https://accounts.google.com",
+        sub: "test-sub",
+      };
+      const result = await service.addUserToCube(req, "test-salt");
+      expect(mockPost).toHaveBeenCalled();
+      expect(result).toBeDefined();
+    });
   });
 });

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

@@ -1,6 +1,21 @@
 import { CONFIG, SIGN_CONFIG } from "./config";
 import { WalletAPIs } from "../wallet";
 import { beforeEach, describe, it, expect, vi, afterEach } from "vitest";
+import axios from "axios";
+
+// Mock axios
+vi.mock("axios", () => ({
+  default: {
+    create: vi.fn(() => ({
+      post: vi.fn(),
+      get: vi.fn(),
+      interceptors: {
+        request: { use: vi.fn() },
+        response: { use: vi.fn() },
+      },
+    })),
+  },
+}));
 
 describe("api", () => {
   let service: WalletAPIs;
@@ -13,7 +28,8 @@ describe("api", () => {
   };
 
   beforeEach(() => {
-    service = WalletAPIs.getInstance(CONFIG, SIGN_CONFIG);
+    // Reset instance before each test
+    (WalletAPIs as any).instance = undefined;
     vi.clearAllMocks();
   });
 
@@ -22,6 +38,69 @@ describe("api", () => {
   });
 
   describe("wallet", () => {
+    it("createWallet should throw when params is missing", async () => {
+      vi.mocked(axios.create).mockReturnValue({
+        post: vi.fn(),
+        get: vi.fn(),
+        interceptors: { request: { use: vi.fn() }, response: { use: vi.fn() } },
+      } as any);
+      service = WalletAPIs.getInstance(CONFIG, SIGN_CONFIG);
+      await expect(service.createWallet(null as any)).rejects.toThrow("Params is required");
+    });
+
+    it("createWallet should return wallet already exists when code 60003", async () => {
+      const mockPost = vi.fn().mockRejectedValue({
+        response: { data: { code: "60003" } },
+      });
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: { request: { use: vi.fn() }, response: { use: vi.fn() } },
+      } as any);
+      service = WalletAPIs.getInstance(CONFIG, SIGN_CONFIG);
+      const result = await service.createWallet({
+        walletId: params.walletId,
+        chainIndex: params.chainIndex,
+        address: params.address,
+        publicKey: params.publicKey,
+        path: params.path,
+        userId: "5001704",
+        source: 2,
+        type: 2,
+        clientType: 4,
+        addressList: [],
+      });
+      expect(result.success).toBe(false);
+      expect(result.message).toBe("Wallet already exists");
+      expect(result.data).toBeNull();
+    });
+
+    it("createWallet should throw on other request error", async () => {
+      const mockPost = vi.fn().mockRejectedValue(new Error("API error"));
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: { request: { use: vi.fn() }, response: { use: vi.fn() } },
+      } as any);
+      service = WalletAPIs.getInstance(CONFIG, SIGN_CONFIG);
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      await expect(
+        service.createWallet({
+          walletId: params.walletId,
+          chainIndex: params.chainIndex,
+          address: params.address,
+          publicKey: params.publicKey,
+          path: params.path,
+          userId: "5001704",
+          source: 2,
+          type: 2,
+          clientType: 4,
+          addressList: [],
+        }),
+      ).rejects.toThrow("API error");
+      consoleSpy.mockRestore();
+    });
+
     it("createWallet", async () => {
       const createParams = {
         walletId: params.walletId,
@@ -36,10 +115,50 @@ describe("api", () => {
         addressList: [],
       };
 
+      const mockResponse = {
+        data: {
+          code: 0,
+          data: {},
+        },
+      };
+      const mockPost = vi.fn().mockResolvedValue(mockResponse);
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: {
+          request: { use: vi.fn() },
+          response: { use: vi.fn() },
+        },
+      } as any);
+
+      // Create service instance after mock is set
+      service = WalletAPIs.getInstance(CONFIG, SIGN_CONFIG);
       const result = await service.createWallet(createParams);
       console.log("createWallet", result);
 
-      expect(result).toEqual(typeof result.data === "object");
+      expect(typeof result.data).toBe("object");
+    });
+
+    it("syncWallet should throw on request error", async () => {
+      const mockPost = vi.fn().mockRejectedValue(new Error("API error"));
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: { request: { use: vi.fn() }, response: { use: vi.fn() } },
+      } as any);
+      service = WalletAPIs.getInstance(CONFIG, SIGN_CONFIG);
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      await expect(
+        service.syncWallet({
+          walletId: params.walletId,
+          chainIndex: params.chainIndex,
+          address: params.address,
+          publicKey: params.publicKey,
+          path: params.path,
+          addressList: [],
+        }),
+      ).rejects.toThrow("API error");
+      consoleSpy.mockRestore();
     });
 
     it("syncWallet", async () => {
@@ -52,10 +171,43 @@ describe("api", () => {
         addressList: [],
       };
 
+      const mockResponse = {
+        data: {
+          code: 0,
+          data: {},
+        },
+      };
+      const mockPost = vi.fn().mockResolvedValue(mockResponse);
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: {
+          request: { use: vi.fn() },
+          response: { use: vi.fn() },
+        },
+      } as any);
+
+      // Create service instance after mock is set
+      service = WalletAPIs.getInstance(CONFIG, SIGN_CONFIG);
       const result = await service.syncWallet(syncParams);
       console.log("syncWallet", result);
 
-      expect(result).toEqual(typeof result.data === "object");
+      expect(typeof result.data).toBe("object");
+    });
+
+    it("deleteWallet should throw on request error", async () => {
+      const mockPost = vi.fn().mockRejectedValue(new Error("API error"));
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: { request: { use: vi.fn() }, response: { use: vi.fn() } },
+      } as any);
+      service = WalletAPIs.getInstance(CONFIG, SIGN_CONFIG);
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      await expect(
+        service.deleteWallet({ walletId: params.walletId, chainIndex: params.chainIndex }),
+      ).rejects.toThrow("API error");
+      consoleSpy.mockRestore();
     });
 
     it("deleteWallet", async () => {
@@ -64,10 +216,28 @@ describe("api", () => {
         chainIndex: params.chainIndex,
       };
 
+      const mockResponse = {
+        data: {
+          code: 0,
+          data: {},
+        },
+      };
+      const mockPost = vi.fn().mockResolvedValue(mockResponse);
+      vi.mocked(axios.create).mockReturnValue({
+        post: mockPost,
+        get: vi.fn(),
+        interceptors: {
+          request: { use: vi.fn() },
+          response: { use: vi.fn() },
+        },
+      } as any);
+
+      // Create service instance after mock is set
+      service = WalletAPIs.getInstance(CONFIG, SIGN_CONFIG);
       const result = await service.deleteWallet(deleteParams);
       console.log("deleteWallet", result);
 
-      expect(result).toEqual(typeof result.data === "object");
+      expect(typeof result.data).toBe("object");
     });
   });
 });

package/src/api/network.ts

@@ -43,11 +43,19 @@ export class NetworkAPIs extends BasePublicService {
     return `tomo-${chainType}-currentChainId`;
   }
 
+  /** Map ChainTypeEnum to network-data platformType where they differ */
+  private static readonly platformTypeForChain: Partial<Record<ChainTypeEnum, string>> = {
+    [ChainTypeEnum.DOGECOIN]: "DOGE",
+    [ChainTypeEnum.BITCOIN]: "BTC",
+  };
+
   public getAllNetworks(chainType: ChainTypeEnum | ""): any[] {
     if (chainType === "") {
       return this.chains;
     }
-    return this.chains.filter((chain) => chain.platformType === chainType.toUpperCase());
+    const platformType =
+      NetworkAPIs.platformTypeForChain[chainType as ChainTypeEnum] ?? chainType.toUpperCase();
+    return this.chains.filter((chain) => chain.platformType === platformType);
   }
 
   public async getCurrentNetwork(chainType: ChainTypeEnum): Promise<string> {

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

@@ -0,0 +1,91 @@
+import { describe, it, expect, vi } from "vitest";
+import { signRequest, formatJwtToken } from "../index";
+
+// Mock signature utils
+vi.mock("../signature", () => ({
+  generateSignature: vi.fn(() => ({
+    signature: "test-signature",
+    timestamp: "1234567890",
+  })),
+}));
+
+describe("api utils", () => {
+  describe("formatJwtToken", () => {
+    it("should format JWT token with Bearer prefix", () => {
+      const result = formatJwtToken("test-token");
+      expect(result).toBe("Bearer test-token");
+    });
+
+    it("should handle empty token", () => {
+      const result = formatJwtToken("");
+      expect(result).toBe("Bearer ");
+    });
+  });
+
+  describe("signRequest", () => {
+    it("should sign request with JWT token string", () => {
+      const params = {
+        method: "GET",
+        url: "/api/test",
+        headers: {},
+      };
+      const clientId = "test-client-id";
+      const jwtToken = "test-jwt-token";
+
+      const result = signRequest(params, clientId, jwtToken);
+      expect(result.headers["client-id"]).toBe(clientId);
+      expect(result.headers.Authorization).toBe("Bearer test-jwt-token");
+    });
+
+    it("should sign request with sign config object", () => {
+      const params = {
+        method: "POST",
+        url: "/api/test",
+        data: { key: "value" },
+        headers: {},
+      };
+      const clientId = "test-client-id";
+      const signConfig = {
+        apiKey: "test-api-key",
+        apiSecret: "test-api-secret",
+        salt: "test-salt",
+      };
+
+      const result = signRequest(params, clientId, signConfig);
+      expect(result.headers["X-APP-Key"]).toBe("test-api-key");
+      expect(result.headers["X-Signature"]).toBe("test-signature");
+      expect(result.headers["X-Timestamp"]).toBe("1234567890");
+      expect(result.headers["client-id"]).toBe(clientId);
+    });
+
+    it("should create headers object if not exists", () => {
+      const params: any = {
+        method: "GET",
+        url: "/api/test",
+      };
+      const clientId = "test-client-id";
+      const jwtToken = "test-jwt-token";
+
+      const result = signRequest(params, clientId, jwtToken);
+      expect(result.headers).toBeDefined();
+      expect(result.headers["client-id"]).toBe(clientId);
+      expect(result.headers.Authorization).toBe("Bearer test-jwt-token");
+    });
+
+    it("should merge with existing headers", () => {
+      const params = {
+        method: "GET",
+        url: "/api/test",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      };
+      const clientId = "test-client-id";
+      const jwtToken = "test-jwt-token";
+
+      const result = signRequest(params, clientId, jwtToken);
+      expect(result.headers["Content-Type"]).toBe("application/json");
+      expect(result.headers["client-id"]).toBe(clientId);
+    });
+  });
+});