@tomo-inc/chains-service 0.0.2

package/src/types/gas.ts

@@ -0,0 +1,53 @@
+export type EVMTransaction = {
+  to: `0x${string}`;
+  value?: string;
+  data?: `${string}`;
+  nonce?: number;
+  gas?: string;
+  gasPrice?: string;
+  maxFeePerGas?: string;
+  maxPriorityFeePerGas?: string;
+};
+
+export interface QueryGasParams {
+  chainIndex: number | string;
+  callData: string;
+  gasLimitParam: {
+    from: string;
+    to: string;
+    value: `0x${string}`;
+  };
+  addressList?: string[];
+}
+
+export interface QueryGasResponse {
+  success: boolean;
+  message?: string;
+  fees?: {
+    low: string | number;
+    medium: string | number;
+    high: string | number;
+  };
+  gasFee?: string | number;
+  rentInfo?: {
+    result?: {
+      minTransferAmount: string;
+      createSplTokenFee?: string;
+    };
+  } | null;
+  baseFee?: string;
+  gasLimit?: string;
+  priorityFee?: {
+    low: string;
+    medium: string;
+    high: string;
+  };
+}
+
+export interface BtcGasFee {
+  fastestFee: number;
+  halfHourFee: number;
+  hourFee: number;
+  economyFee: number;
+  minimumFee: number;
+}

package/src/types/index.ts

@@ -0,0 +1,81 @@
+import { CubeStage, TomoStage } from "@tomo-inc/wallet-utils";
+
+export * from "./account";
+export * from "./dapp";
+export * from "./gas";
+export * from "./network";
+export * from "./tx";
+export * from "./wallet";
+
+export interface TomoAppInfo {
+  tomoStage: TomoStage;
+  tomoClientId: string;
+  apiKey: string;
+  apiSecret: string;
+  salt: string;
+  jwtToken?: string;
+}
+
+export type TokenInfo = any;
+export type AccountToken = any;
+
+export interface ServiceRes {
+  success: boolean;
+  method?: string;
+  data: any;
+}
+
+export enum SubmitParamsType {
+  SWAP = 1,
+  BRIDGE = 2,
+  TRANSFER = 3,
+}
+
+export interface CenterSubmitParams {
+  platform?: number;
+  type?: SubmitParamsType;
+  userId?: string;
+  fromTokenPrice?: number;
+  toTokenPrice?: number;
+  source?: any;
+  slippage?: any;
+  fromAddress?: string;
+  toAddress?: string;
+  fromChainIndex: string;
+  fromTokenAddress?: string;
+  fromAmount?: string;
+  toChainIndex: string;
+  toTokenAddress?: string;
+  toAmount?: any;
+  sourceDex?: string;
+  estimatedGas?: string;
+  failReason?: string;
+  tx?: string;
+  callData: string;
+  extParams?: any;
+}
+
+export interface SendRes {
+  success: boolean;
+  data: {
+    orderId: string;
+    hash: string;
+  };
+}
+
+export interface AddressItem {
+  address: string;
+  subType: string;
+  publicKey: string;
+}
+
+export type SendTransactionConfig = {
+  waitForHash?: boolean;
+};
+
+export interface IConfig {
+  cubeStage: CubeStage;
+  tomoSdkClientId: string;
+  cubeSalt: string;
+  cubeOrgId: string;
+}

package/src/types/network.ts

@@ -0,0 +1,66 @@
+import { ChainTypes } from "@tomo-inc/wallet-utils";
+
+export type NativeCurrency = {
+  symbol: string;
+  decimals: number;
+  name: string;
+  logoURI?: string;
+};
+
+export type RpcInfo = {
+  name: string;
+  url: string;
+};
+
+export type EVMNetwork = `${number}`; // "1", "56"
+export type BTCNetwork = "mainnet" | "testnet" | "signet" | "regtest";
+export type SolNetwork = "mainnet" | "testnet" | "devnet";
+export type SuiNetwork = "mainnet" | "testnet" | "devnet";
+export type DogeNetwork = "mainnet" | "testnet" | "devnet";
+export type TonNetwork = "mainnet" | "testnet" | "devnet";
+export type TronNetwork = "mainnet" | "testnet" | "devnet";
+
+export type ChainTypeIds =
+  | `${ChainTypes.EVM}:${EVMNetwork}`
+  | `${ChainTypes.BTC}:${BTCNetwork}`
+  | `${ChainTypes.SOL}:${SolNetwork}`
+  | `${ChainTypes.SUI}:${SuiNetwork}`
+  | `${ChainTypes.DOGE}:${DogeNetwork}`
+  | `${ChainTypes.TON}:${TonNetwork}`
+  | `${ChainTypes.TRON}:${TronNetwork}`;
+
+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 ChainID = string;
+export interface INetwork {
+  id?: string;
+  type?: ChainTypeIds;
+  rpcInfos?: RpcInfo[]; // update field
+  rpcUrls?: string[];
+  explorerUrls?: string[]; // update field
+  platformType: string;
+  chainId: string | number;
+  sortIndex?: number;
+  nativeCurrency?: NativeCurrency; // update field
+  name: string;
+  icon: string;
+  // --- remote data ---
+  chainIndex?: number; // remote chain index
+  info?: Partial<RemoteChainInfo2>;
+}

package/src/types/tx.ts

@@ -0,0 +1,181 @@
+export interface IUtxo {
+  txid: string;
+  vout: number;
+  status: {
+    confirmed: boolean;
+    block_height: number;
+    block_hash: string;
+    block_time: number;
+  };
+  value: number;
+}
+
+export interface ITypedData {
+  types: any;
+  primaryType: string;
+  domain: any;
+  message: any;
+}
+
+export type BTCNetworkType = "MAINNET" | "TESTNET" | "SIGNET";
+export type BTCNetworkAddressType = "P2PKH" | "P2WPKH" | "P2TR" | "P2SH";
+
+export enum BTCNetworkTypeEnum {
+  MAINNET = "MAINNET",
+  TESTNET = "TESTNET",
+  SIGNET = "SIGNET",
+}
+
+export enum BTCNetworkAddressTypeEnum {
+  P2PKH = "P2PKH",
+  P2WPKH = "P2WPKH",
+  P2TR = "P2TR",
+  P2SH = "P2SH",
+}
+
+export interface BtcCreateSendBtcPsbt {
+  networkType: BTCNetworkType;
+  addressType: BTCNetworkAddressType | undefined;
+  toAddress: string;
+  amount: string;
+}
+
+export interface BtcSignPsbt {
+  networkType: BTCNetworkType;
+  addressType: BTCNetworkAddressType;
+  autoFinalized: boolean;
+  psbtHex: string;
+}
+
+export interface BtcPushTx {
+  networkType: BTCNetworkType;
+  rawTransaction: string;
+}
+
+export type BtcAddressType =
+  | "bitcoinP2pkhAddress"
+  | "bitcoinP2shAddress"
+  | "bitcoinP2trAddress"
+  | "bitcoinP2wpkhAddress";
+
+export type ISwapTokensParams = {
+  chain: number | undefined;
+  page: number | undefined;
+  size: number | undefined;
+  keyword: string | undefined;
+};
+
+export enum SubmitParamsType {
+  SWAP = 1,
+  BRIDGE = 2,
+  TRANSFER = 3,
+}
+
+export interface UTXO {
+  // hash of transaction that holds the UTXO
+  txid: string;
+  // index of the output in the transaction
+  vout: number;
+  // amount of satoshis the UTXO holds
+  value: number;
+  // the script that the UTXO contains
+  scriptPubKey: string;
+}
+
+export type Fees = {
+  // fee for inclusion in the next block
+  fastestFee: number;
+  // fee for inclusion in a block in 30 mins
+  halfHourFee: number;
+  // fee for inclusion in a block in 1 hour
+  hourFee: number;
+  // economy fee: inclusion not guaranteed
+  economyFee: number;
+  // minimum fee: the minimum fee of the network
+  minimumFee: number;
+};
+
+export interface ICreatePsbtArgs {
+  from: string;
+  pubKey: Uint8Array;
+  to: string;
+  amount: string;
+  addressType: BTCNetworkAddressTypeEnum;
+  networkType: BTCNetworkTypeEnum;
+}
+
+export interface UnspentOutput {
+  txId: string;
+  outputIndex: number;
+  satoshis: number;
+  scriptPk: string;
+  addressType?: BTCNetworkAddressTypeEnum;
+  address: string;
+}
+
+export interface TxInput {
+  data: {
+    hash: string;
+    index: number;
+    witnessUtxo: { value: number; script: Uint8Array };
+    tapInternalKey?: Uint8Array;
+  };
+  utxo: UnspentOutput;
+}
+
+export type TransactionParams = Omit<any, "rpcUrl">;
+
+export interface EvmTransaction {
+  data: string | undefined;
+  gas: string | undefined;
+  gasPrice: string | undefined;
+  maxFeePerGas: string | undefined;
+  maxPriorityFeePerGas: string | undefined;
+  nonce: number | undefined;
+  to: string | undefined;
+  from: string | undefined;
+  value?: string | undefined;
+}
+
+export interface EvmTransactionParams {
+  transaction: EvmTransaction;
+  chainId: number;
+}
+
+export interface EvmTransactionWithTypes {
+  data: {
+    data: string | undefined;
+    gas: string | undefined;
+    gasPrice: string | undefined;
+    maxFeePerGas: string | undefined;
+    maxPriorityFeePerGas: string | undefined;
+    nonce: number | undefined;
+    to: string | undefined;
+    from: string | undefined;
+    chainId: number;
+  };
+  types: {
+    [key: string]: string;
+  };
+}
+
+export interface SendTransactionParams {
+  chainId: string;
+  accountId?: string;
+  amount: number;
+  data?: string;
+  decimals?: number;
+  fee: number;
+  from: string;
+  gasFeeUsd?: string;
+  maxFee?: string;
+  to: string;
+  tokenAddress: string;
+  submitType?: SubmitParamsType;
+  value?: string;
+  nonce?: number;
+  maxFeePerGas?: string;
+  maxPriorityFeePerGas?: string;
+  gas?: string;
+  spendableUtxos: any[];
+}

package/src/types/wallet.ts

@@ -0,0 +1,49 @@
+import { ChainTypes } from "@tomo-inc/wallet-utils";
+
+export enum TxTypes {
+  swap = 1,
+  bridge = 2,
+  receive = 31,
+  send = 32,
+  approve = 4,
+  contractInteraction = 5,
+  redPocket = 6,
+}
+
+export interface TransactionsParams {
+  walletId?: string;
+  tokenAddress?: string;
+  chainId?: string;
+  typeList?: TxTypes[];
+  cursor?: string;
+  pageLimit?: number;
+}
+
+export interface TransactionItem {
+  chainType: ChainTypes;
+  chainInfo: {
+    chainId: string;
+    name: string;
+    icon: string;
+  };
+  nativeCurrency: {
+    symbol: string;
+    decimals: number;
+    name: string;
+  };
+  tokenInfo: {
+    tokenAddress: string;
+    symbol: string;
+    logo: string;
+    riskLevel: number;
+  };
+  txHash: `0x${string}`;
+  txDetail: any;
+  txDetailLink: `https://${string}`;
+  txTime: number;
+}
+
+export interface TransactionsResponse {
+  cursor: string;
+  transactionList: TransactionItem[];
+}

package/src/wallet.ts

@@ -0,0 +1,96 @@
+//types
+import { ChainTypes, getExplorerUrl } from "@tomo-inc/wallet-utils";
+
+import { INetwork, NativeCurrency, TomoAppInfo, TransactionsParams, TransactionsResponse } from "./types";
+import { BaseService } from "./base/service";
+
+export class TomoWallet extends BaseService {
+  private static instance: TomoWallet;
+  private walletId: string;
+
+  public constructor(walletId: string, tomoAppInfo: TomoAppInfo) {
+    super(tomoAppInfo);
+    this.walletId = walletId;
+  }
+
+  public getInstance(walletId: string, tomoAppInfo: TomoAppInfo) {
+    if (!TomoWallet.instance) {
+      TomoWallet.instance = new TomoWallet(walletId, tomoAppInfo);
+    }
+    return new TomoWallet(walletId, tomoAppInfo);
+  }
+
+  public async supportedChains(chainType?: ChainTypes | ""): Promise<INetwork[]> {
+    const networks = await this.networks.getNetworks(chainType || "");
+    return networks;
+  }
+
+  public async getChainInfo(chainType: ChainTypes, chainId: string): Promise<INetwork> {
+    this.networks.setChainType(chainType);
+    const network = await this.networks.getNetworkByChainId(chainId);
+    return network;
+  }
+
+  //evm chains
+  public async isChainSupported(chainType: ChainTypes, chainId: string): Promise<boolean> {
+    this.networks.setChainType(chainType);
+    const chainInfo = await this.networks.getNetworkByChainId(chainId);
+    if (!chainInfo) {
+      return false;
+    }
+    return !!chainInfo.chainId;
+  }
+
+  public async getTransactions({
+    tokenAddress = "",
+    chainId = "",
+    typeList = [],
+    pageLimit = 20,
+    cursor,
+  }: TransactionsParams): Promise<TransactionsResponse> {
+    if (!this.walletId) {
+      throw new Error("walletId is required");
+    }
+    try {
+      const params: any = {
+        tokenAddress,
+        pageLimit: pageLimit + 1,
+        walletId: this.walletId,
+        cursor,
+      };
+      if (typeList.length > 0) {
+        params.typeList = typeList.join(",");
+      }
+      if (chainId) {
+        const chainInfo: any = await this.networks.getNetworkByChainId(chainId);
+        const chainIndex = chainInfo.chainIndex;
+        params.chainIndex = chainIndex;
+      }
+      const { cursor: newCursor = "", transactionList } = await this.transactions.getTransactions(params);
+
+      const txList = transactionList.map(async (item: any) => {
+        const chainIndex = item.chainIndex;
+        const chainInfo = (await this.networks.getNetworkByChainIndex(chainIndex)) as INetwork;
+        return {
+          chainType: chainInfo.platformType.toLowerCase() as ChainTypes,
+          chainInfo: {
+            chainId: chainInfo.chainId.toString(),
+            name: chainInfo.name,
+            icon: chainInfo.icon,
+          },
+          nativeCurrency: chainInfo?.nativeCurrency as NativeCurrency,
+          tokenInfo: item.tokenInfo,
+          txHash: item.txHash as `0x${string}`,
+          txDetail: item,
+          txDetailLink: getExplorerUrl(chainIndex, { txId: item.txHash }) as `https://${string}`,
+          txTime: item.txTime,
+        };
+      });
+      const resolvedTxList = await Promise.all(txList);
+      return { cursor: newCursor, transactionList: resolvedTxList };
+    } catch (error) {
+      console.error("Failed to send transaction via RPC:", error);
+      throw error;
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": "./src",
+    "target": "ES2022",
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "types": []
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm", "cjs"],
+  dts: true,
+  treeshake: true,
+  clean: true,
+  target: "es2022",
+  platform: "browser",
+  tsconfig: "tsconfig.json",
+  external: ["viem", "crypto-js", "axios", "bignumber.js", "crypto", "@tomo-wallet/web3", "bitcoinjs-lib"],
+  outExtension({ format }) {
+    return {
+      js: format === "esm" ? ".js" : ".cjs",
+    };
+  },
+});