@tomo-inc/chains-service 0.0.2

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+# @tomo-inc/chains-service
+
+## 0.0.1

package/README.md

@@ -0,0 +1,15 @@
+# @tomo-inc/chains-service
+
+## support
+
+1. rpc APIs: balance, gas, transaction detail,
+2. chainType.EVM
+3. wallet APIs: chains、transaction history
+
+## how to use
+
+demo: packages/social-account-sdk/src/cube-account.ts
+
+## todo
+
+1. support more chainType: SOL、DOGE、TRON、BTC....

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@tomo-inc/chains-service",
+  "version": "0.0.2",
+  "author": "tomo.inc",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "dependencies": {
+    "@solana/spl-token": "^0.4.8",
+    "@solana/web3.js": "^1.98.0",
+    "axios": "^1.11.0",
+    "bignumber.js": "^9.1.2",
+    "bitcoinjs-lib": "^7.0.0",
+    "crypto-js": "4.2.0",
+    "viem": "2.21.54",
+    "@tomo-inc/wallet-utils": "0.0.2"
+  },
+  "devDependencies": {
+    "@types/supertest": "^2.0.12",
+    "@vitest/browser": "^3.2.4",
+    "playwright": "^1.44.1",
+    "supertest": "^6.3.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.0.0",
+    "vitest": "^3.2.4"
+  }
+}

package/project.json

@@ -0,0 +1,59 @@
+{
+  "name": "chains-service",
+  "sourceRoot": "packages/chains-service/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "nx:run-commands",
+      "outputs": ["{projectRoot}/dist"],
+      "options": {
+        "command": "tsup src/index.ts --format esm,cjs --dts --treeshake",
+        "cwd": "packages/chains-service"
+      }
+    },
+    "dev": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "tsup src/index.ts --format esm,cjs --watch --dts",
+        "cwd": "packages/chains-service"
+      }
+    },
+    "lint": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "eslint src/**/*.ts",
+        "cwd": "packages/chains-service"
+      }
+    },
+    "lint:fix": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "eslint src/**/*.ts --fix",
+        "cwd": "packages/chains-service"
+      }
+    },
+    "format": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "prettier --write \"src/**/*.{ts,tsx}\"",
+        "cwd": "packages/chains-service"
+      }
+    },
+    "test": {
+      "executor": "nx:run-commands",
+      "outputs": ["{projectRoot}/coverage"],
+      "options": {
+        "command": "vitest run",
+        "cwd": "packages/chains-service"
+      }
+    },
+    "test:watch": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "vitest",
+        "cwd": "packages/chains-service"
+      }
+    }
+  },
+  "tags": ["npm:private", "scope:chains-service", "type:library"]
+}

package/src/api/__tests__/config.ts

@@ -0,0 +1,21 @@
+import { TomoApiDomains } from "@tomo-inc/wallet-utils";
+const domain = TomoApiDomains["dev"];
+
+export const CONFIG = {
+  rpcBaseUrl: domain,
+  walletBaseUrl: `${domain}/wallet`,
+  txBaseUrl: `${domain}/quote`,
+  tokenBaseUrl: `${domain}/token`,
+  userBaseUrl: `${domain}/user/api`,
+  clientId: "tvmff3fh5I0raW9xMN9zW8wW8WX4uUE9hmYnmwVuzh8rJ7vkglUzsQnzOqeSC8vC39vhPTPUIJFK5DwyHBkRIk4M",
+};
+
+export const SIGN_CONFIG = {
+  apiKey: "*****",
+  apiSecret: "*****",
+  salt: "*****",
+};
+
+export const jwtToken = "";
+
+export const salt = "";

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

@@ -0,0 +1,120 @@
+import { CONFIG, SIGN_CONFIG } from "../__tests__/config";
+import { TokenAPIs } from "../token";
+import { beforeEach, describe, it, expect, vi, afterEach } from "vitest";
+
+describe("api", () => {
+  let service: TokenAPIs;
+  const params = {
+    chainIndex: 50100,
+    chainId: "501",
+    name: "tokenTestName",
+    symbol: "tokenTestSymbol",
+    decimals: 6,
+    logo: "https://assets.tomo.org/token/50100/2NxhyCKNRp7qwhJj9rWHvqZqk6oA9aehDm8XWprDpump.png",
+    address: "2NxhyCKNRp7qwhJj9rWHvqZqk6oA9aehDm8XWprDpump",
+    tokenAddress: "2NxhyCKNRp7qwhJj9rWHvqZqk6oA9aehDm8XWprDpump",
+    walletId: "d1e88058-e979-5637-9daa-7f8cf4b454cb",
+    keyword: "5LThamuNW11L4Zf7mfMY8UKWf3ZByDwHq4CLTkc4bonk",
+    chains: "1,56",
+    assetsType: "multi",
+  };
+
+  beforeEach(() => {
+    service = TokenAPIs.getInstance(CONFIG, SIGN_CONFIG);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("token", () => {
+    it("getTokenInfo", async () => {
+      const result = await service.getTokenInfo(params);
+      console.log("getTokenInfo", result);
+
+      expect(result?.data?.address).toBe(params.address);
+      // expect(result).toEqual(result.success === true);
+    });
+
+    it("getTokenRisk", async () => {
+      const result = await service.getTokenRisk(params);
+      console.log("getTokenRisk", result);
+
+      expect(result?.data?.chainIndex).toBe(params.chainIndex);
+      expect(result?.data?.tokenAddress).toBe(params.tokenAddress);
+    });
+
+    it("deleteCustomToken", async () => {
+      const result = await service.deleteCustomToken(params);
+      console.log("deleteCustomToken", result);
+
+      expect(typeof result.success).toBe("boolean");
+    });
+
+    it("addCustomToken", async () => {
+      const result = await service.addCustomToken(params);
+      console.log("addCustomToken", result);
+
+      expect(typeof result.success).toBe("boolean");
+    });
+
+    it("addMultiToken", async () => {
+      const result = await service.addMultiToken(params);
+
+      console.log("addMultiToken", result);
+
+      expect(typeof result.success).toBe("boolean");
+    });
+
+    it("removeMultiToken", async () => {
+      const result = await service.removeMultiToken(params);
+      console.log("removeMultiToken", result);
+
+      expect(typeof result.success).toBe("boolean");
+    });
+
+    it("syncCustomToken", async () => {
+      const result = await service.syncCustomToken({
+        walletId: params.walletId,
+        chainId: params.chainId,
+        address: params.address,
+        name: params.name,
+        symbol: params.symbol,
+        decimals: params.decimals,
+        logo: params.logo,
+      });
+      console.log("syncCustomToken", result);
+
+      expect(typeof result.success).toBe("boolean");
+    });
+
+    it("getTokenBalance", async () => {
+      const result = await service.getTokenBalance({
+        walletId: params.walletId,
+        assetsType: "multi",
+      });
+      console.log("getTokenBalance", result);
+
+      expect(typeof result.success).toBe("boolean");
+    });
+
+    it("getTokenDetail", async () => {
+      const result = await service.getTokenDetail(params);
+      console.log("getTokenDetail", result);
+
+      expect(typeof result.success).toBe("boolean");
+    });
+
+    it("queryRemoteTokens", async () => {
+      const params = {
+        keyword: "2NxhyCKNRp7qwhJj9rWHvqZqk6oA9aehDm8XWprDpump",
+      };
+
+      const result = await service.queryRemoteTokens(params);
+      console.log("queryRemoteTokens", result);
+
+      expect(typeof result.success).toBe("boolean");
+    });
+  });
+});

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

@@ -0,0 +1,86 @@
+import { CONFIG, SIGN_CONFIG } from "./config";
+import { TransactionAPIs } from "../transaction";
+import { beforeEach, describe, it, expect, vi, afterEach } from "vitest";
+
+describe("api", () => {
+  let service: TransactionAPIs;
+
+  const params = {
+    walletId: "d1e88058-e979-5637-9daa-7f8cf4b454cb",
+    chainIndex: 50100,
+    address: "2NxhyCKNRp7qwhJj9rWHvqZqk6oA9aehDm8XWprDpump",
+    orderId: "order123",
+    chainType: "DOGE",
+    txHash: "txHash123",
+  };
+
+  beforeEach(() => {
+    service = TransactionAPIs.getInstance(CONFIG, SIGN_CONFIG);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("transaction", () => {
+    it("getTransactions", async () => {
+      const result = await service.getTransactions(params);
+      console.log("getTransactions", result);
+
+      expect(typeof result.success).toBe("boolean");
+    });
+
+    it("getTransaction", async () => {
+      const result = await service.getTransaction(params);
+      console.log("getTransaction", result);
+
+      expect(typeof result.success).toBe("boolean");
+    });
+
+    it("queryGasInfo", async () => {
+      const gasParams = {
+        chainType: params.chainType,
+        from: params.address,
+        chainIndex: params.chainIndex,
+        to: "2NxhyCKNRp7qwhJj9rWHvqZqk6oA9aehDm8XWprDpump",
+        callData: "0x",
+        gasLimitParam: {
+          from: params.address,
+          to: "2NxhyCKNRp7qwhJj9rWHvqZqk6oA9aehDm8XWprDpump",
+          value: "1000000",
+        },
+        value: "1000000",
+      };
+
+      const result = await service.queryGasInfo(params.chainType, gasParams);
+      console.log("queryGasInfo", result);
+
+      expect(typeof result.success).toBe("boolean");
+    });
+
+    it("sendTransaction", async () => {
+      const sendParams = {
+        walletId: params.walletId,
+        chainIndex: params.chainIndex,
+        from: params.address,
+        to: "2NxhyCKNRp7qwhJj9rWHvqZqk6oA9aehDm8XWprDpump",
+        value: "1000000",
+        gasPrice: "1000000000",
+        gasLimit: "21000",
+      };
+
+      const result = await service.sendTransaction(sendParams);
+      console.log("sendTransaction", result);
+
+      expect(typeof result.success).toBe("boolean");
+    });
+
+    it("getOrderStatus", async () => {
+      const result = await service.getOrderStatus({ orderId: params.orderId });
+      console.log("getOrderStatus", result);
+
+      expect(typeof result.success).toBe("boolean");
+    });
+  });
+});

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

@@ -0,0 +1,105 @@
+import { CONFIG, jwtToken } from "./config";
+import { UserAPIs } from "../user";
+import { beforeEach, describe, it, expect, vi, afterEach } from "vitest";
+
+describe("api", () => {
+  let service: UserAPIs;
+  const params = {
+    nickname: "Test User",
+    username: "testuser",
+    email: "test@example.com",
+    exportTime: 1759630767526,
+  };
+
+  beforeEach(() => {
+    service = UserAPIs.getInstance(CONFIG, jwtToken);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("user", () => {
+    it("getUserInfo", async () => {
+      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");
+    });
+
+    it("updateUserInfo", async () => {
+      const r = Date.now() % 10;
+      const userInfo = {
+        nickname: `${params.nickname}_${r}`,
+        username: `${params.username}_${r}`,
+      };
+
+      const result = await service.updateUserInfo(userInfo);
+      console.log("updateUserInfo", result);
+
+      expect(typeof result.success).toBe("boolean");
+      expect(typeof result.data).toBe("object");
+      expect(typeof result.data?.userID).toBe("string");
+      expect(result.data?.nickname).toBe(userInfo.nickname);
+      expect(result.data?.username).toBe(userInfo.username);
+    });
+
+    // it("addUserToCube", async () => {
+    //   const cubistIdentity = {
+    //     id: "Proof#DNrsd2A5k=",
+    //     preferred_username: "nuise",
+    //     aud: "Vk13WDUDA6MTpjaQ",
+    //     email: null,
+    //     identity: {
+    //       iss: "https://shim.oauth2.cubist.dev/twitter",
+    //       sub: "18712172",
+    //     },
+    //     user_info: {
+    //       user_id: "User#58cd7c7e-80e7-4887-b735-e47c3a06e0f2",
+    //       initialized: true,
+    //     },
+    //     exp_epoch: 1754910294,
+    //   };
+
+    //   const iss = cubistIdentity?.identity?.iss;
+    //   const sub = cubistIdentity?.identity?.sub;
+
+    //   const req = {
+    //     cubistUserID: cubistIdentity?.user_info?.user_id,
+    //     aud: cubistIdentity?.aud,
+    //     email: cubistIdentity?.email || null,
+    //     iss,
+    //     sub,
+    //     initialized: cubistIdentity?.user_info?.initialized,
+    //   };
+
+    //   const result = await service.addUserToCube(req);
+    //   console.log("addUserToCube", result);
+
+    //   expect(typeof result).toBe("object");
+    // });
+
+    it("getUserWallet", async () => {
+      const result = await service.getUserWallet();
+      console.log("getUserWallet", result);
+
+      expect(typeof result.success).toBe("boolean");
+      expect(typeof result.data).toBe("object");
+      expect(typeof result.data?.id).toBe("string");
+      expect(typeof result.data?.bitcoinP2shPubKeyMain).toBe("string");
+      expect(typeof result.data?.deleted).toBe("boolean");
+      expect(typeof result.data?.solanaAddress).toBe("string");
+    });
+
+    it("isExistEmail", async () => {
+      const result = await service.isExistEmail(params.email);
+      console.log("isExistEmail", result);
+
+      expect(typeof result).toBe("object");
+    });
+  });
+});

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

@@ -0,0 +1,73 @@
+import { CONFIG, SIGN_CONFIG } from "./config";
+import { WalletAPIs } from "../wallet";
+import { beforeEach, describe, it, expect, vi, afterEach } from "vitest";
+
+describe("api", () => {
+  let service: WalletAPIs;
+  const params = {
+    walletId: "d1e88058-e979-5637-9daa-7f8cf4b454cb",
+    chainIndex: 50100,
+    address: "2NxhyCKNRp7qwhJj9rWHvqZqk6oA9aehDm8XWprDpump",
+    publicKey: "publicKey123",
+    path: "m/44'/3'/0'/0/0",
+  };
+
+  beforeEach(() => {
+    service = WalletAPIs.getInstance(CONFIG, SIGN_CONFIG);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("wallet", () => {
+    it("createWallet", async () => {
+      const createParams = {
+        walletId: params.walletId,
+        chainIndex: params.chainIndex,
+        address: params.address,
+        publicKey: params.publicKey,
+        path: params.path,
+        userId: "5001704",
+        source: 2,
+        type: 2 as const,
+        clientType: 4 as const,
+        addressList: [],
+      };
+
+      const result = await service.createWallet(createParams);
+      console.log("createWallet", result);
+
+      expect(result).toEqual(typeof result.data === "object");
+    });
+
+    it("syncWallet", async () => {
+      const syncParams = {
+        walletId: params.walletId,
+        chainIndex: params.chainIndex,
+        address: params.address,
+        publicKey: params.publicKey,
+        path: params.path,
+        addressList: [],
+      };
+
+      const result = await service.syncWallet(syncParams);
+      console.log("syncWallet", result);
+
+      expect(result).toEqual(typeof result.data === "object");
+    });
+
+    it("deleteWallet", async () => {
+      const deleteParams = {
+        walletId: params.walletId,
+        chainIndex: params.chainIndex,
+      };
+
+      const result = await service.deleteWallet(deleteParams);
+      console.log("deleteWallet", result);
+
+      expect(result).toEqual(typeof result.data === "object");
+    });
+  });
+});

package/src/api/base.ts

@@ -0,0 +1,52 @@
+import axios, { AxiosInstance } from "axios";
+import { signRequest } from "./utils";
+import { IPrivateApiBaseConfig, IPublicApiBaseConfig } from "./types";
+import { TomoAppInfo } from "../types";
+
+export class BasePublicService {
+  public tokenApi: AxiosInstance = axios.create();
+  public txApi: AxiosInstance = axios.create();
+  public walletApi: AxiosInstance = axios.create();
+  private apiBase: IPublicApiBaseConfig;
+  private tomoAppInfo: TomoAppInfo;
+
+  public constructor(publicApiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo) {
+    this.apiBase = publicApiBase;
+    this.tomoAppInfo = tomoAppInfo;
+
+    [this.tokenApi, this.txApi, this.walletApi].map((api, i) =>
+      api.interceptors.request.use((params: any) => {
+        const { tokenBaseUrl, txBaseUrl, walletBaseUrl } = publicApiBase;
+        params.baseURL = [tokenBaseUrl, txBaseUrl, walletBaseUrl][i] as string;
+        return signRequest(params, tomoAppInfo.tomoClientId, tomoAppInfo);
+      }),
+    );
+  }
+
+  private getSignConfig() {
+    return this.tomoAppInfo;
+  }
+}
+
+export class BasePrivateService {
+  public userApi: AxiosInstance = axios.create();
+  private apiBase: IPrivateApiBaseConfig;
+  private jwtToken: string;
+
+  public constructor(privateApiBase: IPrivateApiBaseConfig, tomoAppInfo: TomoAppInfo) {
+    this.jwtToken = tomoAppInfo.jwtToken || "";
+    this.apiBase = privateApiBase;
+
+    [this.userApi].map((api, i) =>
+      api.interceptors.request.use((params: any) => {
+        const { userBaseUrl } = privateApiBase;
+        params.baseURL = [userBaseUrl][i] as string;
+        return signRequest(params, tomoAppInfo.tomoClientId, this.jwtToken);
+      }),
+    );
+  }
+
+  public getJwtToken() {
+    return this.jwtToken;
+  }
+}

package/src/api/index.ts

@@ -0,0 +1,24 @@
+import { IPrivateApiBaseConfig, IPublicApiBaseConfig } from "./types";
+import { TomoAppInfo } from "../types";
+import { UserAPIs } from "./user";
+import { TokenAPIs } from "./token";
+import { TransactionAPIs } from "./transaction";
+import { WalletAPIs } from "./wallet";
+import { signature } from "./utils";
+import { NetworkAPIs } from "./network";
+export const utils = { signature };
+
+export function tomoPublicApiService(publicApiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo) {
+  return {
+    tokenAPIs: TokenAPIs.getInstance(publicApiBase, tomoAppInfo),
+    transactionAPIs: TransactionAPIs.getInstance(publicApiBase, tomoAppInfo),
+    networkAPIs: NetworkAPIs.getInstance(publicApiBase, tomoAppInfo),
+    walletAPIs: WalletAPIs.getInstance(publicApiBase, tomoAppInfo),
+  };
+}
+
+export function tomoPrivateApiService(privateApiBase: IPrivateApiBaseConfig, tomoAppInfo: TomoAppInfo) {
+  return {
+    userAPIs: UserAPIs.getInstance(privateApiBase, tomoAppInfo),
+  };
+}