@tomo-inc/chains-service 0.0.2

package/src/api/token.ts

@@ -0,0 +1,182 @@
+import {
+  GetTokenInfoParams,
+  RemoteResponse,
+  RemoteTokenInfo,
+  AddCustomTokenParams,
+  DeleteCustomTokenParams,
+  SyncCustomTokenParams,
+  GetTokenBalanceParams,
+  GetTokenBalanceResponse,
+  IPublicApiBaseConfig,
+} from "./types";
+import { BasePublicService } from "./base";
+import { TomoAppInfo } from "../types";
+
+export class TokenAPIs extends BasePublicService {
+  private static instance: TokenAPIs;
+
+  private constructor(apiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo) {
+    super(apiBase, tomoAppInfo);
+  }
+
+  public static getInstance(apiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo) {
+    if (!this.instance) {
+      this.instance = new TokenAPIs(apiBase, tomoAppInfo);
+    }
+    return this.instance;
+  }
+
+  //  --------------- token api ---------------
+  async getTokenInfo(params: GetTokenInfoParams): Promise<RemoteResponse<RemoteTokenInfo>> {
+    try {
+      const res = await this.walletApi.get("/v1/balance/getTokenInfo", {
+        params,
+      });
+      return {
+        success: res?.data?.code === "00000",
+        message: res?.data?.msg,
+        data: res?.data?.data,
+      };
+    } catch (error) {
+      console.error("Failed to get token info:", error);
+      throw error;
+    }
+  }
+
+  async getTokenRisk(params: { chainIndex: number; tokenAddress: string }): Promise<RemoteResponse<any>> {
+    if (typeof params.chainIndex !== "number" || !params.tokenAddress) {
+      throw new Error("chainName or tokenAddress is required");
+    }
+    const res = await this.tokenApi.post("/v1/market/risk/details", [params]);
+    return {
+      success: res?.data?.code === "0",
+      message: res?.data?.msg,
+      data: res?.data?.data?.[0] || null,
+    };
+  }
+
+  async addCustomToken(params: AddCustomTokenParams): Promise<RemoteResponse<any>> {
+    try {
+      const res = await this.walletApi.post("/v1/customTokens/addCustomToken", params, {});
+      return {
+        success: res?.data?.code === "00000",
+        message: res?.data?.msg,
+        data: res?.data?.data,
+      };
+    } catch (error) {
+      console.error("Failed to add custom token:", error);
+      throw error;
+    }
+  }
+
+  async deleteCustomToken(params: DeleteCustomTokenParams): Promise<RemoteResponse<any>> {
+    try {
+      const res = await this.walletApi.get("/v1/customTokens/delete", {
+        params,
+      });
+      return {
+        success: res?.data?.code === "00000",
+        message: res?.data?.msg,
+        data: res?.data?.data,
+      };
+    } catch (error) {
+      console.error("Failed to delete custom token:", error);
+      throw error;
+    }
+  }
+
+  async addMultiToken(params: AddCustomTokenParams): Promise<RemoteResponse<any>> {
+    try {
+      const res = await this.walletApi.post("/v1/customTokens/addTokenWithMulti", params, {});
+      return {
+        success: res?.data?.code === "00000",
+        message: res?.data?.msg,
+        data: res?.data?.data,
+      };
+    } catch (error) {
+      console.error("Failed to add multi token:", error);
+      throw error;
+    }
+  }
+
+  async removeMultiToken(params: DeleteCustomTokenParams): Promise<RemoteResponse<any>> {
+    try {
+      const res = await this.walletApi.get("/v1/customTokens/hideTokenWithMulti", {
+        params,
+      });
+      return {
+        success: res?.data?.code === "00000",
+        message: res?.data?.msg,
+        data: res?.data?.data,
+      };
+    } catch (error) {
+      console.error("Failed to delete multi token:", error);
+      throw error;
+    }
+  }
+
+  async syncCustomToken(params: SyncCustomTokenParams): Promise<RemoteResponse<any>> {
+    try {
+      const res = await this.walletApi.post("/v1/customTokens/sync", params, {});
+      return res?.data || {};
+    } catch (error) {
+      console.error("Failed to sync custom token:", error);
+      throw error;
+    }
+  }
+
+  async getTokenBalance(params: GetTokenBalanceParams): Promise<RemoteResponse<GetTokenBalanceResponse>> {
+    try {
+      const res = await this.walletApi.get("/v1/balance/getTokenBalanceWithDetail", {
+        params,
+      });
+
+      return {
+        success: res?.data?.code === "00000",
+        message: res?.data?.msg,
+        data: res?.data?.data || null,
+      };
+    } catch (error) {
+      console.error("Failed to get token balance:", error);
+      throw error;
+    }
+  }
+
+  async getTokenDetail(params: { chainIndex: number; tokenAddress: string }): Promise<RemoteResponse<any>> {
+    //bad design, should: chainId + tokenAddress
+    const { chainIndex, tokenAddress } = params;
+
+    const res = await this.tokenApi.get(`/v1/market/token/detail`, {
+      params: {
+        tokenAddress,
+        chainIndex,
+      },
+    });
+
+    return {
+      success: res?.data?.code === "0",
+      message: res?.data?.msg,
+      data: res?.data?.data || null,
+    };
+  }
+
+  async queryRemoteTokens(params: { keyword: string; chainIndex?: number }): Promise<RemoteResponse<any[]>> {
+    const { keyword = "", chainIndex } = params || {};
+    if (!keyword) {
+      throw new Error("Params is required");
+    }
+
+    const res = await this.tokenApi.get(`/v1/market/token/search`, {
+      params: {
+        content: keyword,
+        chainIndex,
+      },
+    });
+
+    return {
+      success: res?.data?.code === "0",
+      message: res?.data?.msg,
+      data: res?.data?.data || [],
+    };
+  }
+}

package/src/api/transaction.ts

@@ -0,0 +1,59 @@
+import {
+  GetGasInfoParams,
+  GetGasInfoResponse,
+  GetTransactionParams,
+  GetTransactionsParams,
+  IPublicApiBaseConfig,
+  RemoteResponse,
+} from "./types";
+import { BasePublicService } from "./base";
+import { TomoAppInfo } from "../types";
+
+export class TransactionAPIs extends BasePublicService {
+  private static instance: TransactionAPIs;
+
+  private constructor(apiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo) {
+    super(apiBase, tomoAppInfo);
+  }
+
+  public static getInstance(apiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo) {
+    if (!this.instance) {
+      this.instance = new TransactionAPIs(apiBase, tomoAppInfo);
+    }
+    return this.instance;
+  }
+
+  async queryGasInfo(chainType: any, params: GetGasInfoParams): Promise<RemoteResponse<GetGasInfoResponse>> {
+    try {
+      const res = await this.txApi.post("/api/v1/quote/queryGasInfo", params);
+      return res?.data || {};
+    } catch (error) {
+      console.error("Failed to get gas info:", error);
+      throw error;
+    }
+  }
+
+  async getTransactions(params: GetTransactionsParams): Promise<RemoteResponse<any>> {
+    try {
+      const res = await this.walletApi.get("/v1/transaction/list", {
+        params,
+      });
+      return res?.data?.data || {};
+    } catch (error) {
+      console.error("Failed to get transactions:", error);
+      throw error;
+    }
+  }
+
+  async getTransaction(params: GetTransactionParams): Promise<RemoteResponse<any>> {
+    try {
+      const res = await this.walletApi.get("/v1/transaction/detail", {
+        params,
+      });
+      return res?.data?.data || {};
+    } catch (error) {
+      console.error("Failed to get transaction:", error);
+      throw error;
+    }
+  }
+}

package/src/api/types/common.ts

@@ -0,0 +1,35 @@
+/**
+ * Common types for API responses and requests
+ */
+
+export interface ApiResponse<T> {
+  code: number;
+  message: string;
+  data: T;
+}
+
+export interface PaginationParams {
+  page: number;
+  pageSize: number;
+}
+
+export interface PaginatedResponse<T> {
+  items: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+}
+
+export interface ApiConfig {
+  baseURL: string;
+  timeout?: number;
+  headers?: Record<string, string>;
+}
+
+export interface RequestOptions {
+  method: "GET" | "POST" | "PUT" | "DELETE";
+  path: string;
+  params?: Record<string, any>;
+  data?: any;
+  headers?: Record<string, string>;
+}

package/src/api/types/index.ts

@@ -0,0 +1,13 @@
+export * from "./common";
+export * from "./type";
+
+export interface IPublicApiBaseConfig {
+  rpcBaseUrl: string;
+  walletBaseUrl: string;
+  txBaseUrl: string;
+  tokenBaseUrl: string;
+}
+
+export interface IPrivateApiBaseConfig {
+  userBaseUrl: string;
+}

package/src/api/types/type.ts

@@ -0,0 +1,283 @@
+export interface ISocialBaseService {
+  setJwtToken(jwtToken: string): void;
+}
+
+export type TomoUserWallet = {
+  createdTime: string;
+  updatedTime: string;
+  id: string;
+  userId: string;
+  ethereumAddress: string;
+  solanaAddress: string;
+  bitcoinP2pkhAddress: string;
+  bitcoinP2trAddress: string;
+  bitcoinP2shAddress: string;
+  bitcoinP2wpkhAddress: string;
+  tonAddress: string;
+  tonAddressTest: string;
+  tonPublicKey: string;
+  tronAddress: string;
+  suiAddress: string;
+  cosmosAddress: string;
+  dogeAddress: string;
+  bitcoinP2pkhAddressTest: string;
+  bitcoinP2pkhPubKeyTest: string;
+  bitcoinP2pkhAddressMain: string;
+  bitcoinP2pkhPubKeyMain: string;
+  bitcoinP2trAddressTest: string;
+  bitcoinP2trPubKeyTest: string;
+  bitcoinP2trAddressMain: string;
+  bitcoinP2trPubKeyMain: string;
+  bitcoinP2shAddressTest: string;
+  bitcoinP2shPubKeyTest: string;
+  bitcoinP2shAddressMain: string;
+  bitcoinP2shPubKeyMain: string;
+  bitcoinP2wpkhAddressTest: string;
+  bitcoinP2wpkhPubKeyTest: string;
+  bitcoinP2wpkhAddressMain: string;
+  bitcoinP2wpkhPubKeyMain: string;
+};
+
+export type TomoUserBaseInfo = {
+  avatar: string;
+  nickname: string;
+  bio: string;
+};
+
+export type TomoUserInfo = TomoUserBaseInfo & {
+  userID: string;
+  accountID: string;
+  tenantID: string;
+  username: string;
+  nickname: string;
+  avatar: string;
+  freePasswordAuth: string;
+  forbidden: boolean;
+  deleted: boolean;
+  updatedTime: string;
+};
+
+export type TokenAssets = {
+  tokenAssets?: AssetInfo[];
+};
+
+export type AssetInfo = {
+  chainIndex: string;
+  tokenAddress: string;
+  symbol: string;
+  balance: string;
+  tokenPrice: string;
+  tokenType: string;
+  isRiskToken: boolean;
+  riskLevel: number;
+  transferAmount: string;
+  availableAmount: string;
+  rawBalance: string;
+  address: string;
+};
+
+export type RemoteChainInfo = {
+  chainName: string;
+  chainId: number;
+  chainIndex: number;
+  support: boolean;
+  orderStatusSupport: boolean;
+  supportBalance: boolean;
+  supportBroadcast: boolean;
+  type: number;
+};
+
+export interface RemoteChainInfo2 {
+  chainId: number;
+  chainIndex: number;
+  name: string;
+  chainName: string;
+  nativeCurrencyName: string;
+  nativeCurrencySymbol: string;
+  nativeCurrencyDecimals: number;
+  rpcUrls?: string[];
+  blockExplorerUrl?: string;
+  platformType: string;
+  isTestnet: boolean;
+  icon: string;
+  supportSwap: boolean;
+  supportGift: boolean;
+  supportHistory: boolean;
+}
+
+export type RemoteTokenInfo = {
+  chainIndex: number;
+  address: string;
+  isNative: boolean;
+  name: string;
+  displayName: string | null;
+  symbol: string;
+  logo: string;
+  decimals: number;
+};
+
+export type RemoteResponse<TData> = {
+  success: boolean;
+  message?: string;
+  data?: TData;
+};
+
+export type CreateWalletParams = {
+  walletId: string;
+  userId: string | number;
+  source: number; //fixed 2. 1:Create, 2:import mnemonic,3:import private key
+  type: 2; //fixed 2. 11:tomo,12:bot,2:WEB3
+  clientType: 4; // fixed 4. (1:telegram,2:ios,3：Android,4:plugin)
+  addressList: AddressListEntity[] | any;
+};
+
+export interface AddressListEntity {
+  chainIndex: number;
+  address: string;
+}
+
+export type SyncWalletParams = {
+  walletId: string;
+  addressList: (AddressListEntity & { operationType: 1 | 2 })[];
+};
+
+export type DeleteWalletParams = {
+  walletId: string;
+};
+
+export type GetTokenInfoParams = {
+  chainIndex: number;
+  address: string;
+};
+
+export type AddCustomTokenParams = {
+  walletId: string;
+  chainIndex: number;
+  address: string;
+};
+
+export type DeleteCustomTokenParams = {
+  walletId: string;
+  chainIndex: number;
+  address: string;
+};
+
+export type SyncCustomTokenParams = {
+  walletId: string;
+  chainId: string;
+  address: string;
+  name: string;
+  symbol: string;
+  decimals: number;
+  logo: string;
+};
+
+export type GetTokenBalanceParams = {
+  walletId: string;
+  chains?: string; // chainIndex1,chainIndex2
+  assetsType: "single" | "multi"; // is token merge by chainIndex or not
+};
+
+export type GetTransactionsParams = {
+  walletId: string;
+  chainIndex: number;
+  tokenAddress?: string;
+  typeList?: number;
+  cursor?: string;
+  pageLimit?: number; // default 10, max 20.
+};
+
+export type GetTransactionParams = {
+  walletId: string;
+  chainIndex: number;
+  txHash: string;
+};
+
+export type InitAccountData = any;
+
+export type TokenBalance = {
+  chainIndex: string;
+  tokenAddress: string;
+  symbol: string;
+  balance: string;
+  isRiskToken: boolean;
+  riskLevel?: number;
+  address: string;
+  tokenPrice: string;
+  priceChangeH24: string;
+  imgUrl: string;
+  decimals: number;
+  name: string;
+  isHidden?: boolean;
+  isMultiChain?: boolean;
+  chainDetails?: [];
+  fourMemeToken?: any;
+};
+export type GetTokenBalanceResponse = {
+  total: string;
+  balance: TokenBalance[];
+};
+
+export type SignEthTypedData = {
+  primaryType: string;
+  types: {
+    additionalProp1: any;
+    additionalProp2: any;
+    additionalProp3: any;
+  };
+  domain: {
+    additionalProp1: any;
+    additionalProp2: any;
+    additionalProp3: any;
+  };
+  message: {
+    additionalProp1: any;
+    additionalProp2: any;
+    additionalProp3: any;
+  };
+};
+
+export type ETHTransactionParams = {
+  transaction: {
+    to: string;
+    from: string;
+    value: string;
+    data: string;
+    nonce: number;
+    gas: string;
+    gasPrice?: string;
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+    minReceiveAmount?: string;
+  };
+  chainId: number;
+};
+
+export type DOGETransactionParams = {
+  rpcUrl: "string";
+  from: "string";
+  to: "string";
+  fee: "string";
+  amount: 0;
+};
+export type SignTransactionParams = ETHTransactionParams | DOGETransactionParams;
+
+export type GasLimitParams = {
+  from: string;
+  to: string;
+  value: string;
+};
+
+export type GetGasInfoParams = {
+  chainIndex: number;
+  callData: string;
+  gasLimitParam: GasLimitParams;
+  addressList?: string[];
+};
+export type GetGasInfoResponse = {
+  gasLimit: string;
+  baseFee: string;
+  priorityFeeLow: string;
+  priorityFeeMedium: string;
+  priorityFeeHigh: string;
+};

package/src/api/user.ts

@@ -0,0 +1,83 @@
+import { IPrivateApiBaseConfig, RemoteResponse, TomoUserInfo, TomoUserWallet } from "./types";
+import { BasePrivateService } from "./base";
+import { signature as signUtils } from "./utils";
+import { TomoAppInfo } from "../types";
+
+export class UserAPIs extends BasePrivateService {
+  private static instance: UserAPIs;
+
+  private constructor(apiBase: IPrivateApiBaseConfig, tomoAppInfo: TomoAppInfo) {
+    super(apiBase, tomoAppInfo);
+  }
+
+  public static getInstance(apiBase: IPrivateApiBaseConfig, tomoAppInfo: TomoAppInfo) {
+    if (!this.instance) {
+      this.instance = new UserAPIs(apiBase, tomoAppInfo);
+    }
+    return this.instance;
+  }
+
+  async getUserInfo(): Promise<RemoteResponse<{ user: TomoUserInfo; accountBaseInfo: any }>> {
+    const res = await this.userApi.post("/api/user/getUserInfo");
+
+    return {
+      success: res?.data?.code.toString() === "10000",
+      message: res?.data?.message,
+      data: res?.data?.data,
+    };
+  }
+
+  async updateUserInfo(userInfo: TomoUserInfo): Promise<RemoteResponse<TomoUserInfo>> {
+    if (!userInfo) throw new Error("User info is required");
+
+    // const { data: userInfoBefore } = await this.getUserInfo();
+    // userInfo = { ...userInfoBefore, ...userInfo };
+
+    const res = await this.userApi.post("/api/setting/updateUserInfo", userInfo);
+    return {
+      success: res?.data?.code.toString() === "10000",
+      message: res?.data?.message,
+      data: res?.data?.data,
+    };
+  }
+
+  async getUserWallet(): Promise<RemoteResponse<TomoUserWallet>> {
+    const res = await this.userApi.post("/api/account/getAccountInfo");
+    return {
+      success: res?.data?.success,
+      message: res?.data?.message,
+      data: res?.data?.data,
+    };
+  }
+
+  async addUserToCube(req: any, salt: string): Promise<RemoteResponse<any>> {
+    // sign for api
+    const { iss, sub } = req;
+    const { timestamp, signature } = await signUtils.generateCubeSignature({ iss, sub }, salt);
+    const signedReq = { ...req, timestamp, signature };
+
+    // send signatrue
+    const res = await this.userApi.post("/api/login/loginByCubistV2", signedReq);
+    return res?.data;
+  }
+
+  async isExistEmail(email: string): Promise<RemoteResponse<any>> {
+    const res = await this.userApi.post(`/api/login/isExistEmail?email=${email}`, { email });
+    return res?.data;
+  }
+
+  async sendExportSeedPhraseEmail(exportTime: number): Promise<RemoteResponse<any>> {
+    const res = await this.userApi.post(`/api/setting/exportSeedSendEmail?exportTime=${exportTime}`, {});
+    return res.data;
+  }
+
+  async sendCancelExportSeedPhraseEmail(): Promise<RemoteResponse<any>> {
+    const res = await this.userApi.post(`/api/setting/cancelExportSeedSendEmail`, {});
+    return res.data;
+  }
+
+  async sendChangeDeviceEmail(exportTime: number): Promise<RemoteResponse<any>> {
+    const res = await this.userApi.post(`/api/setting/changeDeviceSendEmail?exportTime=${exportTime}`, {});
+    return res.data;
+  }
+}

package/src/api/utils/index.ts

@@ -0,0 +1,34 @@
+import { ISignConfig } from "../types";
+import * as signUtils from "./signature";
+export { signUtils as signature };
+export const formatJwtToken = (jwtToken: string) => `Bearer ${jwtToken}`;
+
+export function signRequest(params: any, clientId: string, signParams: ISignConfig | string): any {
+  if (typeof signParams === "string") {
+    const jwtToken = signParams;
+    Object.assign(params.headers ?? {}, {
+      "client-id": clientId,
+      Authorization: formatJwtToken(jwtToken),
+    });
+    return params;
+  }
+
+  const { apiKey, apiSecret, salt } = signParams;
+  const { signature, timestamp } = signUtils.generateSignature({
+    method: params.method,
+    url: params.url,
+    data: params.data,
+    apiKey: apiKey,
+    apiSecret: apiSecret,
+    salt: salt,
+  });
+
+  Object.assign(params.headers ?? {}, {
+    "X-APP-Key": apiKey,
+    "X-Signature": signature,
+    "X-Timestamp": timestamp,
+    "client-id": clientId,
+  });
+
+  return params;
+}