@tomo-inc/chains-service 0.0.23 → 0.0.25

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

@@ -0,0 +1,124 @@
+import { describe, it, expect, vi } from "vitest";
+import { generateSignature, generateCubeSignature } from "../signature";
+
+describe("signature utils", () => {
+  describe("generateSignature", () => {
+    it("should generate signature for GET request", () => {
+      const config = {
+        method: "GET",
+        url: "/api/test",
+        apiKey: "test-api-key",
+        apiSecret: "test-api-secret",
+        salt: "test-salt",
+      };
+
+      const result = generateSignature(config);
+      expect(result).toHaveProperty("signature");
+      expect(result).toHaveProperty("timestamp");
+      expect(typeof result.signature).toBe("string");
+      expect(typeof result.timestamp).toBe("string");
+    });
+
+    it("should generate signature for POST request with data", () => {
+      const config = {
+        method: "POST",
+        url: "/api/test",
+        data: { key: "value" },
+        apiKey: "test-api-key",
+        apiSecret: "test-api-secret",
+        salt: "test-salt",
+      };
+
+      const result = generateSignature(config);
+      expect(result).toHaveProperty("signature");
+      expect(result).toHaveProperty("timestamp");
+    });
+
+    it("should generate signature for POST request with string data", () => {
+      const config = {
+        method: "POST",
+        url: "/api/test",
+        data: '{"key":"value"}',
+        apiKey: "test-api-key",
+        apiSecret: "test-api-secret",
+        salt: "test-salt",
+      };
+
+      const result = generateSignature(config);
+      expect(result).toHaveProperty("signature");
+      expect(result).toHaveProperty("timestamp");
+    });
+
+    it("should generate signature for POST request without data", () => {
+      const config = {
+        method: "POST",
+        url: "/api/test",
+        apiKey: "test-api-key",
+        apiSecret: "test-api-secret",
+        salt: "test-salt",
+      };
+
+      const result = generateSignature(config);
+      expect(result).toHaveProperty("signature");
+      expect(result).toHaveProperty("timestamp");
+    });
+
+    it("should generate different signatures for different timestamps", () => {
+      const config = {
+        method: "GET",
+        url: "/api/test",
+        apiKey: "test-api-key",
+        apiSecret: "test-api-secret",
+        salt: "test-salt",
+      };
+
+      const result1 = generateSignature(config);
+      // Wait a bit to ensure different timestamp
+      vi.useFakeTimers();
+      vi.advanceTimersByTime(1000);
+      const result2 = generateSignature(config);
+      vi.useRealTimers();
+
+      // Signatures should be different due to different timestamps
+      expect(result1.signature).not.toBe(result2.signature);
+    });
+  });
+
+  describe("generateCubeSignature", () => {
+    it("should generate cube signature", async () => {
+      const data = { key: "value" };
+      const salt = "test-salt";
+
+      const result = await generateCubeSignature(data, salt);
+      expect(result).toHaveProperty("timestamp");
+      expect(result).toHaveProperty("signature");
+      expect(typeof result.timestamp).toBe("string");
+      expect(typeof result.signature).toBe("string");
+    });
+
+    it("should throw error when salt is missing", async () => {
+      const data = { key: "value" };
+      await expect(generateCubeSignature(data, "")).rejects.toThrow("salt is required");
+    });
+
+    it("should include timestamp in result", async () => {
+      const data = { key: "value" };
+      const salt = "test-salt";
+
+      const result = await generateCubeSignature(data, salt);
+      expect(result.timestamp).toBeDefined();
+      expect(Number(result.timestamp)).toBeGreaterThan(0);
+    });
+
+    it("should generate different signatures for different data", async () => {
+      const salt = "test-salt";
+      const data1 = { key: "value1" };
+      const data2 = { key: "value2" };
+
+      const result1 = await generateCubeSignature(data1, salt);
+      const result2 = await generateCubeSignature(data2, salt);
+
+      expect(result1.signature).not.toBe(result2.signature);
+    });
+  });
+});

package/src/api/utils/index.ts

@@ -4,9 +4,13 @@ export { signUtils as signature };
 export const formatJwtToken = (jwtToken: string) => `Bearer ${jwtToken}`;
 
 export function signRequest(params: any, clientId: string, signParams: ISignConfig | string): any {
+  if (!params.headers) {
+    params.headers = {};
+  }
+
   if (typeof signParams === "string") {
     const jwtToken = signParams;
-    Object.assign(params.headers ?? {}, {
+    Object.assign(params.headers, {
       "client-id": clientId,
       Authorization: formatJwtToken(jwtToken),
     });
@@ -23,7 +27,7 @@ export function signRequest(params: any, clientId: string, signParams: ISignConf
     salt: salt,
   });
 
-  Object.assign(params.headers ?? {}, {
+  Object.assign(params.headers, {
     "X-APP-Key": apiKey,
     "X-Signature": signature,
     "X-Timestamp": timestamp,

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

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { Networks } from "../network";
+import { NetworkAPIs } from "../../api/network";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
+import { CONFIG, SIGN_CONFIG } from "../../api/__tests__/config";
+
+describe("Networks", () => {
+  let networks: Networks;
+  let mockNetworkAPIs: NetworkAPIs;
+
+  const mockTomoAppInfo = {
+    tomoStage: "dev" as const,
+    tomoClientId: SIGN_CONFIG.clientId || "",
+  };
+
+  beforeEach(() => {
+    mockNetworkAPIs = NetworkAPIs.getInstance(CONFIG, mockTomoAppInfo);
+    networks = new Networks(mockNetworkAPIs);
+  });
+
+  describe("constructor", () => {
+    it("should create Networks instance with default chainType", () => {
+      const networksInstance = new Networks(mockNetworkAPIs);
+      expect(networksInstance).toBeInstanceOf(Networks);
+    });
+
+    it("should create Networks instance with specific chainType", () => {
+      const networksInstance = new Networks(mockNetworkAPIs, ChainTypeEnum.EVM);
+      expect(networksInstance).toBeInstanceOf(Networks);
+    });
+  });
+
+  describe("setChainType", () => {
+    it("should set chain type", () => {
+      networks.setChainType(ChainTypeEnum.EVM);
+      expect((networks as any).chainType).toBe(ChainTypeEnum.EVM);
+    });
+  });
+
+  describe("getNetworks", () => {
+    it("should return networks for specific chain type", async () => {
+      const result = await networks.getNetworks(ChainTypeEnum.EVM);
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.every((n) => n.platformType === "EVM")).toBe(true);
+    });
+
+    it("should return all networks when chainType is empty", async () => {
+      const result = await networks.getNetworks("");
+      expect(Array.isArray(result)).toBe(true);
+    });
+
+    it("should use default chainType when not provided", async () => {
+      const networksInstance = new Networks(mockNetworkAPIs, ChainTypeEnum.EVM);
+      const result = await networksInstance.getNetworks();
+      expect(Array.isArray(result)).toBe(true);
+    });
+  });
+
+  describe("getNetworkByChainId", () => {
+    it("should return network by chainId", async () => {
+      const network = await networks.getNetworkByChainId("1");
+      expect(network).toBeDefined();
+      expect(network.chainId).toBe(1);
+    });
+
+    it("should throw error if network not found", async () => {
+      await expect(networks.getNetworkByChainId("99999")).rejects.toThrow("Network not found");
+    });
+  });
+
+  describe("getNetworkByChainIndex", () => {
+    it("should return network by chainIndex", async () => {
+      const network = await networks.getNetworkByChainIndex(100);
+      expect(network).toBeDefined();
+      expect(network.chainIndex).toBe(100);
+    });
+
+    it("should throw error if network not found", async () => {
+      await expect(networks.getNetworkByChainIndex(99999)).rejects.toThrow("Network not found");
+    });
+  });
+
+  describe("getCurrentNetwork", () => {
+    it("should return current network", async () => {
+      networks.setChainType(ChainTypeEnum.EVM);
+      const network = await networks.getCurrentNetwork();
+      expect(network).toBeDefined();
+      expect(network.platformType).toBe("EVM");
+    });
+
+    it("should use default chainId from SupportedChainTypes if cache is empty", async () => {
+      networks.setChainType(ChainTypeEnum.EVM);
+      const network = await networks.getCurrentNetwork();
+      expect(network).toBeDefined();
+    });
+
+    it("should use SupportedChainTypes fallback when getCurrentNetwork returns empty string", async () => {
+      networks.setChainType(ChainTypeEnum.EVM);
+      vi.spyOn(networks.networkAPIs, "getCurrentNetwork").mockResolvedValue("");
+      const network = await networks.getCurrentNetwork();
+      expect(network).toBeDefined();
+      expect(network.platformType).toBe("EVM");
+    });
+  });
+
+  describe("setCurrentNetwork", () => {
+    it("should set current network", async () => {
+      networks.setChainType(ChainTypeEnum.EVM);
+      const result = await networks.setCurrentNetwork("56");
+      expect(result).toBe(true);
+    });
+
+    it("should set current network with empty chainType", async () => {
+      const networksInstance = new Networks(mockNetworkAPIs);
+      const result = await networksInstance.setCurrentNetwork("1");
+      expect(result).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi } from "vitest";
+import { BaseService } from "../service";
+import { SIGN_CONFIG } from "../../api/__tests__/config";
+
+// Mock tomoPublicApiService
+vi.mock("../../api", () => {
+  return {
+    tomoPublicApiService: vi.fn(() => ({
+      tokenAPIs: {},
+      transactionAPIs: {},
+      networkAPIs: {},
+    })),
+  };
+});
+
+describe("BaseService", () => {
+  const mockTomoAppInfo = {
+    tomoStage: "dev" as const,
+    tomoClientId: SIGN_CONFIG.clientId || "",
+  };
+
+  const mockAccountInfo = {
+    getCurrent: vi.fn(),
+    signMessage: vi.fn(),
+    signTransaction: vi.fn(),
+    signTypedData: vi.fn(),
+  };
+
+  describe("constructor", () => {
+    it("should create BaseService instance with valid tomoStage", () => {
+      const service = new BaseService(mockTomoAppInfo);
+      expect(service).toBeInstanceOf(BaseService);
+      expect(service.networks).toBeDefined();
+      expect(service.tokens).toBeDefined();
+      expect(service.transactions).toBeDefined();
+      expect(service.isDappConnected).toBe(false);
+    });
+
+    it("should create BaseService instance with accountInfo", () => {
+      const service = new BaseService(mockTomoAppInfo, mockAccountInfo as any);
+      expect(service.accountInfo).toBe(mockAccountInfo);
+    });
+
+    it("should throw error for invalid tomoStage", () => {
+      const invalidAppInfo = {
+        tomoStage: "invalid" as any,
+        tomoClientId: SIGN_CONFIG.clientId || "",
+      };
+      expect(() => new BaseService(invalidAppInfo)).toThrow("Tomo stage is required");
+    });
+
+    it("should throw error when tomoStage is missing", () => {
+      const invalidAppInfo = {
+        tomoClientId: SIGN_CONFIG.clientId || "",
+      } as any;
+      expect(() => new BaseService(invalidAppInfo)).toThrow("Tomo stage is required");
+    });
+  });
+
+  describe("setApproveParams", () => {
+    it("should set approve params", () => {
+      const service = new BaseService(mockTomoAppInfo);
+      const params = { token: "0x123", amount: "100" };
+      service.setApproveParams(params);
+      expect(service.approveParams).toEqual(params);
+    });
+  });
+});

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

@@ -0,0 +1,123 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { Tokens } from "../token";
+import { TokenAPIs } from "../../api/token";
+import { CONFIG, SIGN_CONFIG } from "../../api/__tests__/config";
+
+describe("Tokens", () => {
+  let tokens: Tokens;
+  let mockTokenAPIs: TokenAPIs;
+
+  beforeEach(() => {
+    mockTokenAPIs = TokenAPIs.getInstance(CONFIG, {
+      tomoStage: "dev" as const,
+      tomoClientId: SIGN_CONFIG.clientId || "",
+    });
+    tokens = new Tokens(mockTokenAPIs);
+  });
+
+  describe("constructor", () => {
+    it("should create Tokens instance", () => {
+      expect(tokens).toBeInstanceOf(Tokens);
+      expect(tokens.tokenAPIs).toBe(mockTokenAPIs);
+    });
+  });
+
+  describe("searchTokens", () => {
+    it("should search tokens by keyword", async () => {
+      const mockTokens = [
+        {
+          address: "0x123",
+          symbol: "TEST",
+          name: "Test Token",
+        },
+      ];
+      vi.spyOn(mockTokenAPIs, "queryRemoteTokens").mockResolvedValue({
+        data: mockTokens,
+      } as any);
+
+      const result = await tokens.searchTokens({ keyword: "TEST" });
+      expect(result).toEqual(mockTokens);
+      expect(mockTokenAPIs.queryRemoteTokens).toHaveBeenCalledWith({ keyword: "TEST", chainIndex: undefined });
+    });
+
+    it("should search tokens with chainIndex", async () => {
+      const mockTokens = [
+        {
+          address: "0x123",
+          symbol: "TEST",
+          name: "Test Token",
+        },
+      ];
+      vi.spyOn(mockTokenAPIs, "queryRemoteTokens").mockResolvedValue({
+        data: mockTokens,
+      } as any);
+
+      const result = await tokens.searchTokens({ keyword: "TEST", chainIndex: 100 });
+      expect(result).toEqual(mockTokens);
+      expect(mockTokenAPIs.queryRemoteTokens).toHaveBeenCalledWith({ keyword: "TEST", chainIndex: 100 });
+    });
+
+    it("should return empty array when no tokens found", async () => {
+      vi.spyOn(mockTokenAPIs, "queryRemoteTokens").mockResolvedValue({
+        data: [],
+      } as any);
+
+      const result = await tokens.searchTokens({ keyword: "NONEXISTENT" });
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("getTokenInfo", () => {
+    it("should get token info", async () => {
+      const mockTokenInfo = {
+        address: "0x123",
+        symbol: "TEST",
+        name: "Test Token",
+        decimals: 18,
+      };
+      vi.spyOn(mockTokenAPIs, "getTokenInfo").mockResolvedValue({
+        data: {
+          data: mockTokenInfo,
+        },
+      } as any);
+
+      const result = await tokens.getTokenInfo({ address: "0x123", chainIndex: 100 });
+      expect(result).toEqual(mockTokenInfo);
+      expect(mockTokenAPIs.getTokenInfo).toHaveBeenCalledWith({ address: "0x123", chainIndex: 100 });
+    });
+  });
+
+  describe("getTokenRiskInfo", () => {
+    it("should get token risk info", async () => {
+      const mockRiskInfo = {
+        riskLevel: "low",
+        riskScore: 10,
+      };
+      vi.spyOn(mockTokenAPIs, "getTokenRisk").mockResolvedValue({
+        data: mockRiskInfo,
+      } as any);
+
+      const result = await tokens.getTokenRiskInfo({ address: "0x123", chainIndex: 100 });
+      expect(result).toEqual(mockRiskInfo);
+      expect(mockTokenAPIs.getTokenRisk).toHaveBeenCalledWith({ address: "0x123", chainIndex: 100 });
+    });
+  });
+
+  describe("getTokenDetail", () => {
+    it("should get token detail", async () => {
+      const mockDetail = {
+        address: "0x123",
+        symbol: "TEST",
+        name: "Test Token",
+        totalSupply: "1000000",
+      };
+      vi.spyOn(mockTokenAPIs, "getTokenDetail").mockResolvedValue({
+        data: mockDetail,
+      } as any);
+
+      const result = await tokens.getTokenDetail({ address: "0x123", chainIndex: 100 });
+      expect(result).toEqual(mockDetail);
+      expect(mockTokenAPIs.getTokenDetail).toHaveBeenCalledWith({ address: "0x123", chainIndex: 100 });
+    });
+  });
+});

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

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { Transactions } from "../transaction";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
+
+describe("Transactions", () => {
+  let transactions: Transactions;
+  let mockTransactionAPIs: any;
+
+  beforeEach(() => {
+    mockTransactionAPIs = {
+      queryGasInfo: vi.fn(),
+      getTransactions: vi.fn(),
+      getTransaction: vi.fn(),
+    };
+    transactions = new Transactions(mockTransactionAPIs as any);
+  });
+
+  describe("queryGasInfo", () => {
+    it("should query gas info successfully", async () => {
+      const mockResponse = {
+        code: 0,
+        result: {
+          baseFee: 1000000000,
+          gasLimit: 21000,
+          priorityFeeHigh: 2000000000,
+          priorityFeeLow: 1000000000,
+          priorityFeeMedium: 1500000000,
+        },
+      };
+      mockTransactionAPIs.queryGasInfo.mockResolvedValue(mockResponse);
+
+      const result = await transactions.queryGasInfo({
+        chainType: ChainTypeEnum.EVM,
+        params: { chainId: "1" },
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(mockResponse.result);
+      expect(mockTransactionAPIs.queryGasInfo).toHaveBeenCalledWith(ChainTypeEnum.EVM, { chainId: "1" });
+    });
+
+    it("should handle query gas info error", async () => {
+      mockTransactionAPIs.queryGasInfo.mockRejectedValue(new Error("Network error"));
+
+      const result = await transactions.queryGasInfo({
+        chainType: ChainTypeEnum.EVM,
+        params: { chainId: "1" },
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.message).toBe("Network error");
+    });
+
+    it("should handle query gas info with non-zero code", async () => {
+      const mockResponse = {
+        code: 1,
+        message: "Invalid chain",
+      };
+      mockTransactionAPIs.queryGasInfo.mockResolvedValue(mockResponse);
+
+      const result = await transactions.queryGasInfo({
+        chainType: ChainTypeEnum.EVM,
+        params: { chainId: "999" },
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.data).toEqual({});
+    });
+
+    it("should handle query gas info with missing error message", async () => {
+      mockTransactionAPIs.queryGasInfo.mockRejectedValue({});
+
+      const result = await transactions.queryGasInfo({
+        chainType: ChainTypeEnum.EVM,
+        params: { chainId: "1" },
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.message).toBe("Failed to query gas info");
+    });
+  });
+
+  describe("getTransactions", () => {
+    it("should get transactions successfully", async () => {
+      const mockResponse = {
+        cursor: "next-cursor",
+        transactionList: [
+          {
+            txHash: "0x123",
+            chainIndex: 100,
+            tokenInfo: {},
+          },
+        ],
+      };
+      mockTransactionAPIs.getTransactions.mockResolvedValue(mockResponse);
+
+      const result = await transactions.getTransactions({
+        walletId: "test-wallet-id",
+        chainIndex: 100,
+        pageLimit: 20,
+      });
+
+      expect(result.cursor).toBe("next-cursor");
+      expect(result.transactionList).toEqual(mockResponse.transactionList);
+      expect(mockTransactionAPIs.getTransactions).toHaveBeenCalledWith({
+        walletId: "test-wallet-id",
+        chainIndex: 100,
+        pageLimit: 20,
+      });
+    });
+
+    it("should handle getTransactions with cursor", async () => {
+      const mockResponse = {
+        cursor: "next-page",
+        transactionList: [],
+      };
+      mockTransactionAPIs.getTransactions.mockResolvedValue(mockResponse);
+
+      const result = await transactions.getTransactions({
+        walletId: "test-wallet-id",
+        chainIndex: 100,
+        cursor: "prev-cursor",
+      });
+
+      expect(result.cursor).toBe("next-page");
+      expect(mockTransactionAPIs.getTransactions).toHaveBeenCalledWith({
+        walletId: "test-wallet-id",
+        chainIndex: 100,
+        cursor: "prev-cursor",
+      });
+    });
+
+    it("should handle getTransactions with empty response", async () => {
+      mockTransactionAPIs.getTransactions.mockResolvedValue(null);
+
+      const result = await transactions.getTransactions({
+        walletId: "test-wallet-id",
+        chainIndex: 100,
+      });
+
+      expect(result.cursor).toBe("");
+      expect(result.transactionList).toEqual([]);
+    });
+
+    it("should handle getTransactions with missing cursor", async () => {
+      const mockResponse = {
+        transactionList: [],
+      };
+      mockTransactionAPIs.getTransactions.mockResolvedValue(mockResponse);
+
+      const result = await transactions.getTransactions({
+        walletId: "test-wallet-id",
+        chainIndex: 100,
+      });
+
+      expect(result.cursor).toBe("");
+      expect(result.transactionList).toEqual([]);
+    });
+  });
+
+  describe("getTransaction", () => {
+    it("should get transaction successfully", async () => {
+      const mockResponse = {
+        data: {
+          txHash: "0x123",
+          chainIndex: 100,
+          tokenInfo: {},
+        },
+      };
+      mockTransactionAPIs.getTransaction.mockResolvedValue(mockResponse);
+
+      const result = await transactions.getTransaction({
+        walletId: "test-wallet-id",
+        txHash: "0x123",
+        chainIndex: 100,
+      });
+
+      expect(result).toEqual(mockResponse.data);
+      expect(mockTransactionAPIs.getTransaction).toHaveBeenCalledWith({
+        walletId: "test-wallet-id",
+        txHash: "0x123",
+        chainIndex: 100,
+      });
+    });
+
+    it("should handle getTransaction with empty response", async () => {
+      mockTransactionAPIs.getTransaction.mockResolvedValue({});
+
+      const result = await transactions.getTransaction({
+        walletId: "test-wallet-id",
+        txHash: "0x123",
+        chainIndex: 100,
+      });
+
+      expect(result).toEqual({});
+    });
+
+    it("should handle getTransaction with missing data", async () => {
+      mockTransactionAPIs.getTransaction.mockResolvedValue(null);
+
+      const result = await transactions.getTransaction({
+        walletId: "test-wallet-id",
+        txHash: "0x123",
+        chainIndex: 100,
+      });
+
+      expect(result).toEqual({});
+    });
+  });
+});

package/src/config.ts

@@ -1,6 +1,6 @@
 import { TomoApiDomains, TomoStage } from "@tomo-inc/wallet-utils";
 
-function getConfig(tomoStage: TomoStage) {
+export function getConfig(tomoStage: TomoStage) {
   const domain = TomoApiDomains[tomoStage];
   if (!domain) {
     throw new Error("Invalid tomo stage");
@@ -18,4 +18,5 @@ export const CONFIG = {
   prod: getConfig("prod"),
   pre: getConfig("pre"),
   dev: getConfig("dev"),
+  "prod-dogeos": getConfig("prod-dogeos"),
 };