@tomo-inc/chains-service 0.0.5 → 0.0.6

package/dist/index.d.ts

@@ -0,0 +1,524 @@
+import { ChainTypes, TomoStage } from '@tomo-inc/wallet-utils';
+import { Transaction } from 'viem';
+import { AxiosInstance } from 'axios';
+
+declare enum AccountType {
+    EOA = "EOA",
+    SOCIAL = "SOCIAL"
+}
+interface ChainAddress {
+    subType: string;
+    address: string;
+    path: string;
+    publicKey?: string;
+    privateKey?: string;
+}
+interface IAccount {
+    readonly id: string;
+    readonly userId?: string | number;
+    readonly name: string;
+    readonly type: AccountType;
+    readonly lastUsedTime: number;
+    readonly sortIndex?: number;
+    readonly addresses: Record<ChainTypes, ChainAddress[]>;
+    readonly mnemonic: string | null;
+    readonly addressIndex: number;
+    readonly isImported: boolean;
+    readonly isBackedUp: boolean;
+    readonly isLocked: boolean;
+    readonly isFrozen: boolean;
+    readonly externalId?: string | number;
+    readonly totalAssets?: string;
+}
+interface IaccountInfo {
+    getCurrent: () => Promise<any[]>;
+    signMessage: (message: string) => Promise<string>;
+    signTypedData: (message: any) => Promise<string>;
+    signTransaction: (transaction: any) => Promise<string>;
+}
+
+interface QueryGasParams {
+    chainIndex: number | string;
+    callData: string;
+    gasLimitParam: {
+        from: string;
+        to: string;
+        value: `0x${string}`;
+    };
+    addressList?: string[];
+}
+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;
+    };
+}
+
+type NativeCurrency = {
+    symbol: string;
+    decimals: number;
+    name: string;
+    logoURI?: string;
+};
+type RpcInfo = {
+    name: string;
+    url: string;
+};
+type EVMNetwork = `${number}`;
+type BTCNetwork = "mainnet" | "testnet" | "signet" | "regtest";
+type SolNetwork = "mainnet" | "testnet" | "devnet";
+type SuiNetwork = "mainnet" | "testnet" | "devnet";
+type DogeNetwork = "mainnet" | "testnet" | "devnet";
+type TonNetwork = "mainnet" | "testnet" | "devnet";
+type TronNetwork = "mainnet" | "testnet" | "devnet";
+type ChainTypeIds = `${ChainTypes.EVM}:${EVMNetwork}` | `${ChainTypes.BTC}:${BTCNetwork}` | `${ChainTypes.SOL}:${SolNetwork}` | `${ChainTypes.SUI}:${SuiNetwork}` | `${ChainTypes.DOGE}:${DogeNetwork}` | `${ChainTypes.TON}:${TonNetwork}` | `${ChainTypes.TRON}:${TronNetwork}`;
+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;
+}
+interface INetwork {
+    id?: string;
+    type?: ChainTypeIds;
+    rpcInfos?: RpcInfo[];
+    rpcUrls?: string[];
+    explorerUrls?: string[];
+    platformType: string;
+    chainId: string | number;
+    sortIndex?: number;
+    nativeCurrency?: NativeCurrency;
+    name: string;
+    icon: string;
+    chainIndex?: number;
+    info?: Partial<RemoteChainInfo2>;
+}
+
+interface ITypedData {
+    types: any;
+    primaryType: string;
+    domain: any;
+    message: any;
+}
+type TransactionParams = Omit<any, "rpcUrl">;
+
+declare enum TxTypes {
+    swap = 1,
+    bridge = 2,
+    receive = 31,
+    send = 32,
+    approve = 4,
+    contractInteraction = 5,
+    redPocket = 6
+}
+interface TransactionsParams {
+    walletId?: string;
+    tokenAddress?: string;
+    chainId?: string;
+    typeList?: TxTypes[];
+    cursor?: string;
+    pageLimit?: number;
+}
+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;
+}
+interface TransactionsResponse {
+    cursor: string;
+    transactionList: TransactionItem[];
+}
+
+interface TomoAppInfo {
+    tomoStage: TomoStage;
+    tomoClientId: string;
+    apiKey: string;
+    apiSecret: string;
+    salt: string;
+    jwtToken?: string;
+}
+type TokenInfo = any;
+
+type RemoteTokenInfo = {
+    chainIndex: number;
+    address: string;
+    isNative: boolean;
+    name: string;
+    displayName: string | null;
+    symbol: string;
+    logo: string;
+    decimals: number;
+};
+type RemoteResponse<TData> = {
+    success: boolean;
+    message?: string;
+    data?: TData;
+};
+type GetTokenInfoParams = {
+    chainIndex: number;
+    address: string;
+};
+type AddCustomTokenParams = {
+    walletId: string;
+    chainIndex: number;
+    address: string;
+};
+type DeleteCustomTokenParams = {
+    walletId: string;
+    chainIndex: number;
+    address: string;
+};
+type SyncCustomTokenParams = {
+    walletId: string;
+    chainId: string;
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    logo: string;
+};
+type GetTokenBalanceParams = {
+    walletId: string;
+    chains?: string;
+    assetsType: "single" | "multi";
+};
+type GetTransactionsParams = {
+    walletId: string;
+    chainIndex: number;
+    tokenAddress?: string;
+    typeList?: number;
+    cursor?: string;
+    pageLimit?: number;
+};
+type GetTransactionParams = {
+    walletId: string;
+    chainIndex: number;
+    txHash: string;
+};
+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;
+};
+type GetTokenBalanceResponse = {
+    total: string;
+    balance: TokenBalance[];
+};
+type GasLimitParams = {
+    from: string;
+    to: string;
+    value: string;
+};
+type GetGasInfoParams = {
+    chainIndex: number;
+    callData: string;
+    gasLimitParam: GasLimitParams;
+    addressList?: string[];
+};
+type GetGasInfoResponse = {
+    gasLimit: string;
+    baseFee: string;
+    priorityFeeLow: string;
+    priorityFeeMedium: string;
+    priorityFeeHigh: string;
+};
+
+interface IPublicApiBaseConfig {
+    rpcBaseUrl: string;
+    walletBaseUrl: string;
+    txBaseUrl: string;
+    tokenBaseUrl: string;
+}
+
+declare class BasePublicService {
+    tokenApi: AxiosInstance;
+    txApi: AxiosInstance;
+    walletApi: AxiosInstance;
+    private apiBase;
+    private tomoAppInfo;
+    constructor(publicApiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo);
+    private getSignConfig;
+}
+
+declare class NetworkAPIs extends BasePublicService {
+    private static instance;
+    chains: INetwork[];
+    currentChainId: string;
+    private constructor();
+    static getInstance(apiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo): NetworkAPIs;
+    getCacheId(chainType: ChainTypes | ""): string;
+    getAllNetworks(chainType: ChainTypes | ""): any[];
+    getCurrentNetwork(chainType: ChainTypes): Promise<string>;
+    setCurrentNetwork(chainType: ChainTypes | "", chainId: string): Promise<void>;
+    getNetworkByChainId(chainId: string): INetwork | undefined;
+    getNetworkByChainIndex(chainIndex: number): INetwork | undefined;
+}
+
+declare class Networks {
+    private chainType;
+    networkAPIs: NetworkAPIs;
+    constructor(networkAPIs: NetworkAPIs, chainType?: ChainTypes);
+    setChainType(chainType: ChainTypes): void;
+    getNetworks(chainType?: ChainTypes | ""): Promise<INetwork[]>;
+    getNetworkByChainId(chainId: string): Promise<INetwork>;
+    getNetworkByChainIndex(chainIndex: number): Promise<INetwork>;
+    getCurrentNetwork(): Promise<INetwork>;
+    setCurrentNetwork(chainId: string): Promise<boolean>;
+}
+
+declare class TokenAPIs extends BasePublicService {
+    private static instance;
+    private constructor();
+    static getInstance(apiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo): TokenAPIs;
+    getTokenInfo(params: GetTokenInfoParams): Promise<RemoteResponse<RemoteTokenInfo>>;
+    getTokenRisk(params: {
+        chainIndex: number;
+        tokenAddress: string;
+    }): Promise<RemoteResponse<any>>;
+    addCustomToken(params: AddCustomTokenParams): Promise<RemoteResponse<any>>;
+    deleteCustomToken(params: DeleteCustomTokenParams): Promise<RemoteResponse<any>>;
+    addMultiToken(params: AddCustomTokenParams): Promise<RemoteResponse<any>>;
+    removeMultiToken(params: DeleteCustomTokenParams): Promise<RemoteResponse<any>>;
+    syncCustomToken(params: SyncCustomTokenParams): Promise<RemoteResponse<any>>;
+    getTokenBalance(params: GetTokenBalanceParams): Promise<RemoteResponse<GetTokenBalanceResponse>>;
+    getTokenDetail(params: {
+        chainIndex: number;
+        tokenAddress: string;
+    }): Promise<RemoteResponse<any>>;
+    queryRemoteTokens(params: {
+        keyword: string;
+        chainIndex?: number;
+    }): Promise<RemoteResponse<any[]>>;
+}
+
+declare class Tokens {
+    tokenAPIs: TokenAPIs;
+    constructor(tokenService: TokenAPIs);
+    searchTokens({ chainIndex, query }: {
+        chainIndex?: number;
+        query?: string;
+    }): Promise<TokenInfo[]>;
+    getTokenInfo({ address, chainIndex }: {
+        address: string;
+        chainIndex: number;
+    }): Promise<TokenInfo>;
+    getTokenRiskInfo(_params: {
+        chainIndex: number;
+        tokenAddress: string;
+    }): Promise<any>;
+    getTokenDetail(_params: {
+        chainName: string;
+        chainIndex: number;
+        tokenAddress: string;
+    }): Promise<any>;
+}
+
+declare class TransactionAPIs extends BasePublicService {
+    private static instance;
+    private constructor();
+    static getInstance(apiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo): TransactionAPIs;
+    queryGasInfo(chainType: any, params: GetGasInfoParams): Promise<RemoteResponse<GetGasInfoResponse>>;
+    getTransactions(params: GetTransactionsParams): Promise<RemoteResponse<any>>;
+    getTransaction(params: GetTransactionParams): Promise<RemoteResponse<any>>;
+}
+
+declare class Transactions {
+    transactionAPIs: TransactionAPIs;
+    constructor(transactionAPIs: TransactionAPIs);
+    queryGasInfo({ chainType, params }: {
+        chainType: string;
+        params: QueryGasParams;
+    }): Promise<any>;
+    getTransactions(params: {
+        walletId: string;
+        chainIndex: number;
+        pageLimit?: number;
+        cursor?: string;
+    }): Promise<{
+        cursor: string;
+        transactionList: any[];
+    }>;
+    getTransaction(params: {
+        walletId: string;
+        txHash: string;
+        chainIndex: number;
+    }): Promise<any>;
+}
+
+declare class BaseService {
+    isDappConnected: boolean;
+    approveParams: any;
+    accountInfo: any;
+    networks: Networks;
+    tokens: Tokens;
+    transactions: Transactions;
+    constructor(tomoAppInfo: TomoAppInfo, accountInfo?: any);
+    setApproveParams(params: any): Promise<void>;
+}
+
+declare class EvmService extends BaseService {
+    private static instance;
+    chainType: ChainTypes | "";
+    constructor(chainType: ChainTypes, accountInfo: IaccountInfo, tomoAppInfo: TomoAppInfo);
+    static getInstance(chainType: ChainTypes, accountInfo: any, tomoAppInfo: TomoAppInfo): EvmService;
+    eth_requestAccounts(): Promise<string[]>;
+    eth_accounts(): Promise<string[]>;
+    eth_chainId(): Promise<`0x${string}`>;
+    private getCurrentChain;
+    wallet_switchEthereumChain(networks: any[]): Promise<boolean>;
+    private isChainSupported;
+    personal_sign([message, address]: [`0x${string}`, `0x${string}`]): Promise<`0x${string}`>;
+    eth_signTypedData_v4([address, typedData]: [`0x${string}`, ITypedData]): Promise<`0x${string}`>;
+    eth_getBalance([address, type]: [`0x${string}`, "latest"]): Promise<string>;
+    _queryGasInfo(txData: TransactionParams): Promise<QueryGasResponse>;
+    eth_estimateGas(txs: Transaction[]): Promise<`0x${string}`>;
+    private createPublicClient;
+    eth_getTransactionCount([address, type]: [`0x${string}`, "latest" | "pending"]): Promise<number>;
+    eth_signTransaction(txParams: {
+        type?: number;
+        from: `0x${string}`;
+        to: `0x${string}`;
+        value: `0x${string}`;
+        data?: `0x${string}`;
+        chainId: `0x${string}`;
+        nonce: `0x${string}`;
+        gasLimit: `0x${string}`;
+        maxFeePerGas?: `0x${string}`;
+        maxPriorityFeePerGas?: `0x${string}`;
+        accessList?: any[];
+    }[]): Promise<Transaction>;
+    eth_sendRawTransaction([serializedTransaction]: [`0x${string}`], rpcUrl?: `https://${string}`): Promise<`0x${string}`>;
+    getTransaction(hash: `0x${string}`): Promise<Transaction>;
+}
+
+interface SolanaRentInfo {
+    minTransferAmount: string;
+    createSplTokenFee: string | null;
+}
+interface QueryRentParams {
+    toAddress: string;
+    tokenAddress?: string;
+}
+
+declare class SolanaService extends BaseService {
+    private static instance;
+    chainType: ChainTypes | "";
+    rpcUrl: string;
+    private connection;
+    constructor(chainType: ChainTypes, accountInfo: IaccountInfo, tomoAppInfo: TomoAppInfo);
+    static getInstance(chainType: ChainTypes, accountInfo: any, tomoAppInfo: TomoAppInfo): SolanaService;
+    getCurrentWalletAccount(): Promise<any>;
+    getAccount(): Promise<{
+        publicKey: string;
+        address: string;
+    }>;
+    signMessage(params: any): Promise<{
+        message: string;
+        signature: string;
+        publicKey: string;
+    }>;
+    signIn(params: any): Promise<{
+        address: string;
+        publicKey: string;
+        signature: string;
+        signedMessage: string;
+    }>;
+    request({ method, params }: {
+        method: string;
+        params: any;
+    }): Promise<any>;
+    _queryGasInfo(txData: TransactionParams): Promise<QueryGasResponse>;
+    sendSignedTx(signedTx: string): Promise<string>;
+    signTransaction({ rawTransaction }: {
+        rawTransaction: string;
+    }): Promise<string>;
+    signAndSendTransaction({ rawTransaction }: {
+        rawTransaction: string;
+    }): Promise<string>;
+    signAllTransactions({ rawTransactions }: {
+        rawTransactions: string[];
+    }): Promise<void>;
+    signAndSendAllTransactions({ rawTransactions }: {
+        rawTransactions: string[];
+    }): Promise<void>;
+    queryRent(params: QueryRentParams): Promise<SolanaRentInfo>;
+    private checkAccountExists;
+    private checkTokenAccount;
+}
+
+declare class TomoWallet extends BaseService {
+    private static instance;
+    private walletId;
+    constructor(walletId: string, tomoAppInfo: TomoAppInfo);
+    getInstance(walletId: string, tomoAppInfo: TomoAppInfo): TomoWallet;
+    supportedChains(chainType?: ChainTypes | ""): Promise<INetwork[]>;
+    getChainInfo(chainType: ChainTypes, chainId: string): Promise<INetwork>;
+    isChainSupported(chainType: ChainTypes, chainId: string): Promise<boolean>;
+    getTransactions({ tokenAddress, chainId, typeList, pageLimit, cursor, }: TransactionsParams): Promise<TransactionsResponse>;
+}
+
+declare const ChainTypeServices: {
+    evm: typeof EvmService;
+    sol: typeof SolanaService;
+};
+
+export { AccountType, type ChainAddress, ChainTypeServices, EvmService, type IAccount, SolanaService, type TomoAppInfo, TomoWallet, type TransactionItem, type TransactionsParams, type TransactionsResponse, TxTypes };