@tomo-inc/chains-service 0.0.18 → 0.0.20

package/dist/index.cjs

@@ -4,8 +4,8 @@ var walletUtils = require('@tomo-inc/wallet-utils');
 var axios = require('axios');
 var CryptoJS = require('crypto-js');
 var Bignumber = require('bignumber.js');
-var bitcoinjsLib = require('bitcoinjs-lib');
 var viem = require('viem');
+var bitcoinjsLib = require('bitcoinjs-lib');
 var splToken = require('@solana/spl-token');
 var web3_js = require('@solana/web3.js');
 
@@ -2868,11 +2868,8 @@ var Tokens = class {
   //   return success;
   // }
 };
-({
-  [walletUtils.ChainTypes.BTC]: true,
-  [walletUtils.ChainTypes.COSMOS]: true,
-  [walletUtils.ChainTypes.DOGE]: true
-});
+
+// src/base/transaction.ts
 var Transactions = class {
   transactionAPIs;
   constructor(transactionAPIs) {
@@ -3973,7 +3970,7 @@ function fromBase64(base64) {
 function toBase58(data) {
   throw new Error("toBase58 requires bs58 package. Install it: pnpm add bs58");
 }
-var BaseConfig = walletUtils.SupportedChainTypes[walletUtils.ChainTypes.DOGE];
+var BaseConfig = walletUtils.SupportedChainTypes[walletUtils.ChainTypeEnum.DOGE];
 var BLOCK_CONFIRMATIONS = 1;
 var FEE_RATE_KB = 0.5;
 var DECIMALS = 1e8;
@@ -4471,6 +4468,8 @@ var DogecoinUtils = class {
     }
   }
 };
+
+// src/dogecoin/service.ts
 var DogecoinService = class _DogecoinService extends BaseService {
   static instance;
   chainType;
@@ -4890,7 +4889,7 @@ var EvmService = class _EvmService extends BaseService {
     });
     if (!success) {
       console.error("queryGasInfo evm", txData, queryGasParams, message, gasInfo);
-      const BaseConfig3 = walletUtils.SupportedChainTypes[walletUtils.ChainTypes.EVM];
+      const BaseConfig3 = walletUtils.SupportedChainTypes[walletUtils.ChainTypeEnum.EVM];
       const { gasFee } = BaseConfig3;
       return {
         success: true,
@@ -4959,7 +4958,7 @@ var EvmService = class _EvmService extends BaseService {
       return gas;
     } catch (error) {
       console.warn("Failed to estimate gas:", error);
-      const BaseConfig3 = walletUtils.SupportedChainTypes[walletUtils.ChainTypes.EVM];
+      const BaseConfig3 = walletUtils.SupportedChainTypes[walletUtils.ChainTypeEnum.EVM];
       const { gasFee } = BaseConfig3;
       return viem.numberToHex(viem.parseUnits(gasFee.toString(), 18));
     }
@@ -5066,7 +5065,7 @@ var EvmService = class _EvmService extends BaseService {
     }
   }
 };
-var BaseConfig2 = walletUtils.SupportedChainTypes[walletUtils.ChainTypes.SOL];
+var BaseConfig2 = walletUtils.SupportedChainTypes[walletUtils.ChainTypeEnum.SOL];
 var TOKEN_METADATA_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
 var MSG_PREFIX = "\xFFsolana offchain";
 
@@ -5463,9 +5462,9 @@ var TomoWallet = class _TomoWallet extends BaseService {
 
 // src/index.ts
 var ChainTypeServices = {
-  [walletUtils.ChainTypes.EVM]: EvmService,
-  [walletUtils.ChainTypes.SOL]: SolanaService,
-  [walletUtils.ChainTypes.DOGE]: DogecoinService
+  [walletUtils.ChainTypeEnum.EVM]: EvmService,
+  [walletUtils.ChainTypeEnum.SOLANA]: SolanaService,
+  [walletUtils.ChainTypeEnum.DOGECOIN]: DogecoinService
 };
 
 exports.AccountType = AccountType;

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { ChainTypes, TomoStage } from '@tomo-inc/wallet-utils';
+import { ChainTypeEnum, TomoStage } from '@tomo-inc/wallet-utils';
 import * as axios from 'axios';
 import { AxiosInstance } from 'axios';
 import { Transaction as Transaction$1 } from 'viem';
@@ -22,7 +22,7 @@ interface IAccount {
     readonly type: AccountType;
     readonly lastUsedTime?: number;
     readonly sortIndex?: number;
-    readonly addresses: Record<ChainTypes, ChainAddress[]>;
+    readonly addresses: Record<ChainTypeEnum, ChainAddress[]>;
     readonly mnemonic: string | null;
     readonly addressIndex: number;
     readonly isImported: boolean;
@@ -91,7 +91,7 @@ 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}`;
+type ChainTypeIds = `${ChainTypeEnum.EVM}:${EVMNetwork}` | `${ChainTypeEnum.BITCOIN}:${BTCNetwork}` | `${ChainTypeEnum.SOLANA}:${SolNetwork}` | `${ChainTypeEnum.SUI}:${SuiNetwork}` | `${ChainTypeEnum.DOGECOIN}:${DogeNetwork}` | `${ChainTypeEnum.TON}:${TonNetwork}` | `${ChainTypeEnum.TRON}:${TronNetwork}`;
 interface RemoteChainInfo2 {
     chainId: number;
     chainIndex: number;
@@ -151,7 +151,7 @@ interface TransactionsParams {
     pageLimit?: number;
 }
 interface TransactionItem {
-    chainType: ChainTypes;
+    chainType: ChainTypeEnum;
     chainInfo: {
         chainId: string;
         name: string;
@@ -308,10 +308,10 @@ declare class NetworkAPIs extends BasePublicService {
     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>;
+    getCacheId(chainType: ChainTypeEnum | ""): string;
+    getAllNetworks(chainType: ChainTypeEnum | ""): any[];
+    getCurrentNetwork(chainType: ChainTypeEnum): Promise<string>;
+    setCurrentNetwork(chainType: ChainTypeEnum | "", chainId: string): Promise<void>;
     getNetworkByChainId(chainId: string): INetwork | undefined;
     getNetworkByChainIndex(chainIndex: number): INetwork | undefined;
 }
@@ -319,9 +319,9 @@ declare class NetworkAPIs extends BasePublicService {
 declare class Networks {
     private chainType;
     networkAPIs: NetworkAPIs;
-    constructor(networkAPIs: NetworkAPIs, chainType?: ChainTypes);
-    setChainType(chainType: ChainTypes): void;
-    getNetworks(chainType?: ChainTypes | ""): Promise<INetwork[]>;
+    constructor(networkAPIs: NetworkAPIs, chainType?: ChainTypeEnum);
+    setChainType(chainType: ChainTypeEnum): void;
+    getNetworks(chainType?: ChainTypeEnum | ""): Promise<INetwork[]>;
     getNetworkByChainId(chainId: string): Promise<INetwork>;
     getNetworkByChainIndex(chainIndex: number): Promise<INetwork>;
     getCurrentNetwork(): Promise<INetwork>;
@@ -514,10 +514,10 @@ declare namespace API {
 
 declare class DogecoinService extends BaseService {
     private static instance;
-    chainType: ChainTypes | "";
+    chainType: ChainTypeEnum | "";
     rpcService: typeof API;
-    constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
-    static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): DogecoinService;
+    constructor(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
+    static getInstance(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): DogecoinService;
     requestAccounts(): Promise<string[]>;
     getAccounts(): Promise<string[]>;
     getConnectionStatus(): Promise<{
@@ -584,9 +584,9 @@ declare class DogecoinService extends BaseService {
 
 declare class EvmService extends BaseService {
     private static instance;
-    chainType: ChainTypes | "";
-    constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
-    static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): EvmService;
+    chainType: ChainTypeEnum | "";
+    constructor(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
+    static getInstance(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): EvmService;
     eth_requestAccounts(): Promise<string[]>;
     eth_accounts(): Promise<string[]>;
     eth_chainId(): Promise<`0x${string}`>;
@@ -630,11 +630,11 @@ interface QueryRentParams {
 
 declare class SolanaService extends BaseService {
     private static instance;
-    chainType: ChainTypes | "";
+    chainType: ChainTypeEnum | "";
     rpcUrl: string;
     private connection;
-    constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
-    static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): SolanaService;
+    constructor(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
+    static getInstance(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): SolanaService;
     getCurrentWalletAccount(): Promise<any[]>;
     getAccount(): Promise<{
         publicKey: string;
@@ -679,9 +679,9 @@ declare class TomoWallet extends BaseService {
     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>;
+    supportedChains(chainType?: ChainTypeEnum | ""): Promise<INetwork[]>;
+    getChainInfo(chainType: ChainTypeEnum, chainId: string): Promise<INetwork>;
+    isChainSupported(chainType: ChainTypeEnum, chainId: string): Promise<boolean>;
     getTransactions({ tokenAddress, chainId, typeList, pageLimit, cursor, }: TransactionsParams): Promise<TransactionsResponse>;
 }
 
@@ -784,8 +784,8 @@ declare class DogecoinUtils {
 
 declare const ChainTypeServices: {
     evm: typeof EvmService;
-    sol: typeof SolanaService;
-    doge: typeof DogecoinService;
+    solana: typeof SolanaService;
+    dogecoin: typeof DogecoinService;
 };
 
 export { AccountType, type ChainAddress, ChainTypeServices, API as DogecoinAPI, DogecoinAddress, DogecoinService, DogecoinUtils, EvmService, type IAccount, type IAccountInfo, SolanaService, type TomoAppInfo, TomoWallet, type TransactionItem, TransactionParser, type TransactionsParams, type TransactionsResponse, TxTypes, addUsedUtxos, createPsbt, decodePsbt, getUsedUtxos, toBitcoin, toSatoshi, type utxoTx };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ChainTypes, TomoStage } from '@tomo-inc/wallet-utils';
+import { ChainTypeEnum, TomoStage } from '@tomo-inc/wallet-utils';
 import * as axios from 'axios';
 import { AxiosInstance } from 'axios';
 import { Transaction as Transaction$1 } from 'viem';
@@ -22,7 +22,7 @@ interface IAccount {
     readonly type: AccountType;
     readonly lastUsedTime?: number;
     readonly sortIndex?: number;
-    readonly addresses: Record<ChainTypes, ChainAddress[]>;
+    readonly addresses: Record<ChainTypeEnum, ChainAddress[]>;
     readonly mnemonic: string | null;
     readonly addressIndex: number;
     readonly isImported: boolean;
@@ -91,7 +91,7 @@ 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}`;
+type ChainTypeIds = `${ChainTypeEnum.EVM}:${EVMNetwork}` | `${ChainTypeEnum.BITCOIN}:${BTCNetwork}` | `${ChainTypeEnum.SOLANA}:${SolNetwork}` | `${ChainTypeEnum.SUI}:${SuiNetwork}` | `${ChainTypeEnum.DOGECOIN}:${DogeNetwork}` | `${ChainTypeEnum.TON}:${TonNetwork}` | `${ChainTypeEnum.TRON}:${TronNetwork}`;
 interface RemoteChainInfo2 {
     chainId: number;
     chainIndex: number;
@@ -151,7 +151,7 @@ interface TransactionsParams {
     pageLimit?: number;
 }
 interface TransactionItem {
-    chainType: ChainTypes;
+    chainType: ChainTypeEnum;
     chainInfo: {
         chainId: string;
         name: string;
@@ -308,10 +308,10 @@ declare class NetworkAPIs extends BasePublicService {
     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>;
+    getCacheId(chainType: ChainTypeEnum | ""): string;
+    getAllNetworks(chainType: ChainTypeEnum | ""): any[];
+    getCurrentNetwork(chainType: ChainTypeEnum): Promise<string>;
+    setCurrentNetwork(chainType: ChainTypeEnum | "", chainId: string): Promise<void>;
     getNetworkByChainId(chainId: string): INetwork | undefined;
     getNetworkByChainIndex(chainIndex: number): INetwork | undefined;
 }
@@ -319,9 +319,9 @@ declare class NetworkAPIs extends BasePublicService {
 declare class Networks {
     private chainType;
     networkAPIs: NetworkAPIs;
-    constructor(networkAPIs: NetworkAPIs, chainType?: ChainTypes);
-    setChainType(chainType: ChainTypes): void;
-    getNetworks(chainType?: ChainTypes | ""): Promise<INetwork[]>;
+    constructor(networkAPIs: NetworkAPIs, chainType?: ChainTypeEnum);
+    setChainType(chainType: ChainTypeEnum): void;
+    getNetworks(chainType?: ChainTypeEnum | ""): Promise<INetwork[]>;
     getNetworkByChainId(chainId: string): Promise<INetwork>;
     getNetworkByChainIndex(chainIndex: number): Promise<INetwork>;
     getCurrentNetwork(): Promise<INetwork>;
@@ -514,10 +514,10 @@ declare namespace API {
 
 declare class DogecoinService extends BaseService {
     private static instance;
-    chainType: ChainTypes | "";
+    chainType: ChainTypeEnum | "";
     rpcService: typeof API;
-    constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
-    static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): DogecoinService;
+    constructor(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
+    static getInstance(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): DogecoinService;
     requestAccounts(): Promise<string[]>;
     getAccounts(): Promise<string[]>;
     getConnectionStatus(): Promise<{
@@ -584,9 +584,9 @@ declare class DogecoinService extends BaseService {
 
 declare class EvmService extends BaseService {
     private static instance;
-    chainType: ChainTypes | "";
-    constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
-    static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): EvmService;
+    chainType: ChainTypeEnum | "";
+    constructor(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
+    static getInstance(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): EvmService;
     eth_requestAccounts(): Promise<string[]>;
     eth_accounts(): Promise<string[]>;
     eth_chainId(): Promise<`0x${string}`>;
@@ -630,11 +630,11 @@ interface QueryRentParams {
 
 declare class SolanaService extends BaseService {
     private static instance;
-    chainType: ChainTypes | "";
+    chainType: ChainTypeEnum | "";
     rpcUrl: string;
     private connection;
-    constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
-    static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): SolanaService;
+    constructor(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
+    static getInstance(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): SolanaService;
     getCurrentWalletAccount(): Promise<any[]>;
     getAccount(): Promise<{
         publicKey: string;
@@ -679,9 +679,9 @@ declare class TomoWallet extends BaseService {
     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>;
+    supportedChains(chainType?: ChainTypeEnum | ""): Promise<INetwork[]>;
+    getChainInfo(chainType: ChainTypeEnum, chainId: string): Promise<INetwork>;
+    isChainSupported(chainType: ChainTypeEnum, chainId: string): Promise<boolean>;
     getTransactions({ tokenAddress, chainId, typeList, pageLimit, cursor, }: TransactionsParams): Promise<TransactionsResponse>;
 }
 
@@ -784,8 +784,8 @@ declare class DogecoinUtils {
 
 declare const ChainTypeServices: {
     evm: typeof EvmService;
-    sol: typeof SolanaService;
-    doge: typeof DogecoinService;
+    solana: typeof SolanaService;
+    dogecoin: typeof DogecoinService;
 };
 
 export { AccountType, type ChainAddress, ChainTypeServices, API as DogecoinAPI, DogecoinAddress, DogecoinService, DogecoinUtils, EvmService, type IAccount, type IAccountInfo, SolanaService, type TomoAppInfo, TomoWallet, type TransactionItem, TransactionParser, type TransactionsParams, type TransactionsResponse, TxTypes, addUsedUtxos, createPsbt, decodePsbt, getUsedUtxos, toBitcoin, toSatoshi, type utxoTx };

package/dist/index.js

@@ -1,9 +1,9 @@
-import { ChainTypes, SupportedChainTypes, TomoApiDomains, cache, getExplorerUrl } from '@tomo-inc/wallet-utils';
+import { SupportedChainTypes, ChainTypeEnum, TomoApiDomains, cache, getExplorerUrl } from '@tomo-inc/wallet-utils';
 import axios from 'axios';
 import CryptoJS from 'crypto-js';
 import Bignumber, { BigNumber } from 'bignumber.js';
-import { Psbt, Transaction, address } from 'bitcoinjs-lib';
 import { toHex as toHex$1, parseUnits, isAddressEqual, createPublicClient, http, hexToBigInt, numberToHex, isHex, fromHex as fromHex$1, parseTransaction, formatUnits, encodeFunctionData, erc20Abi } from 'viem';
+import { Psbt, Transaction, address } from 'bitcoinjs-lib';
 import { getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { PublicKey, Connection, VersionedTransaction, sendAndConfirmRawTransaction, Transaction as Transaction$1, SystemProgram, LAMPORTS_PER_SOL } from '@solana/web3.js';
 
@@ -2860,11 +2860,8 @@ var Tokens = class {
   //   return success;
   // }
 };
-({
-  [ChainTypes.BTC]: true,
-  [ChainTypes.COSMOS]: true,
-  [ChainTypes.DOGE]: true
-});
+
+// src/base/transaction.ts
 var Transactions = class {
   transactionAPIs;
   constructor(transactionAPIs) {
@@ -3965,7 +3962,7 @@ function fromBase64(base64) {
 function toBase58(data) {
   throw new Error("toBase58 requires bs58 package. Install it: pnpm add bs58");
 }
-var BaseConfig = SupportedChainTypes[ChainTypes.DOGE];
+var BaseConfig = SupportedChainTypes[ChainTypeEnum.DOGE];
 var BLOCK_CONFIRMATIONS = 1;
 var FEE_RATE_KB = 0.5;
 var DECIMALS = 1e8;
@@ -4463,6 +4460,8 @@ var DogecoinUtils = class {
     }
   }
 };
+
+// src/dogecoin/service.ts
 var DogecoinService = class _DogecoinService extends BaseService {
   static instance;
   chainType;
@@ -4882,7 +4881,7 @@ var EvmService = class _EvmService extends BaseService {
     });
     if (!success) {
       console.error("queryGasInfo evm", txData, queryGasParams, message, gasInfo);
-      const BaseConfig3 = SupportedChainTypes[ChainTypes.EVM];
+      const BaseConfig3 = SupportedChainTypes[ChainTypeEnum.EVM];
       const { gasFee } = BaseConfig3;
       return {
         success: true,
@@ -4951,7 +4950,7 @@ var EvmService = class _EvmService extends BaseService {
       return gas;
     } catch (error) {
       console.warn("Failed to estimate gas:", error);
-      const BaseConfig3 = SupportedChainTypes[ChainTypes.EVM];
+      const BaseConfig3 = SupportedChainTypes[ChainTypeEnum.EVM];
       const { gasFee } = BaseConfig3;
       return numberToHex(parseUnits(gasFee.toString(), 18));
     }
@@ -5058,7 +5057,7 @@ var EvmService = class _EvmService extends BaseService {
     }
   }
 };
-var BaseConfig2 = SupportedChainTypes[ChainTypes.SOL];
+var BaseConfig2 = SupportedChainTypes[ChainTypeEnum.SOL];
 var TOKEN_METADATA_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
 var MSG_PREFIX = "\xFFsolana offchain";
 
@@ -5455,9 +5454,9 @@ var TomoWallet = class _TomoWallet extends BaseService {
 
 // src/index.ts
 var ChainTypeServices = {
-  [ChainTypes.EVM]: EvmService,
-  [ChainTypes.SOL]: SolanaService,
-  [ChainTypes.DOGE]: DogecoinService
+  [ChainTypeEnum.EVM]: EvmService,
+  [ChainTypeEnum.SOLANA]: SolanaService,
+  [ChainTypeEnum.DOGECOIN]: DogecoinService
 };
 
 export { AccountType, ChainTypeServices, rpc_exports as DogecoinAPI, DogecoinAddress, DogecoinService, DogecoinUtils, EvmService, SolanaService, TomoWallet, TransactionParser, TxTypes, addUsedUtxos, createPsbt, decodePsbt, getUsedUtxos, toBitcoin, toSatoshi };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomo-inc/chains-service",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "author": "tomo.inc",
   "license": "MIT",
   "private": false,
@@ -23,7 +23,7 @@
     "bitcoinjs-lib": "^7.0.0",
     "crypto-js": "4.2.0",
     "viem": "2.21.54",
-    "@tomo-inc/wallet-utils": "0.0.16"
+    "@tomo-inc/wallet-utils": "0.0.18"
   },
   "devDependencies": {
     "@types/supertest": "^2.0.12",

package/src/api/network.ts

@@ -1,4 +1,4 @@
-import { ChainTypes, SupportedChainTypes } from "@tomo-inc/wallet-utils";
+import { ChainTypeEnum, SupportedChainTypes } from "@tomo-inc/wallet-utils";
 import { INetwork, TomoAppInfo } from "../types";
 import { BasePublicService } from "./base";
 import { loadNetworks } from "./network-data";
@@ -39,18 +39,18 @@ export class NetworkAPIs extends BasePublicService {
     return this.instance;
   }
 
-  public getCacheId(chainType: ChainTypes | ""): string {
+  public getCacheId(chainType: ChainTypeEnum | ""): string {
     return `tomo-${chainType}-currentChainId`;
   }
 
-  public getAllNetworks(chainType: ChainTypes | ""): any[] {
+  public getAllNetworks(chainType: ChainTypeEnum | ""): any[] {
     if (chainType === "") {
       return this.chains;
     }
     return this.chains.filter((chain) => chain.platformType === chainType.toUpperCase());
   }
 
-  public async getCurrentNetwork(chainType: ChainTypes): Promise<string> {
+  public async getCurrentNetwork(chainType: ChainTypeEnum): Promise<string> {
     if (!SupportedChainTypes?.[chainType]) {
       throw new Error(`Chain ${chainType} is not supported`);
     }
@@ -60,7 +60,7 @@ export class NetworkAPIs extends BasePublicService {
     return currentChainId || SupportedChainTypes?.[chainType]?.chainId || this.currentChainId || "";
   }
 
-  public async setCurrentNetwork(chainType: ChainTypes | "", chainId: string): Promise<void> {
+  public async setCurrentNetwork(chainType: ChainTypeEnum | "", chainId: string): Promise<void> {
     if (chainType && !SupportedChainTypes?.[chainType]) {
       throw new Error(`Chain ${chainType} is not supported`);
     }

package/src/base/network.ts

@@ -1,23 +1,23 @@
-import { ChainTypes, SupportedChainTypes } from "@tomo-inc/wallet-utils";
+import { ChainTypeEnum, SupportedChainTypes } from "@tomo-inc/wallet-utils";
 
-import { INetwork } from "../types";
 import { NetworkAPIs } from "../api/network";
+import { INetwork } from "../types";
 
 //chainType = all for wallet
 export class Networks {
-  private chainType: ChainTypes | "";
+  private chainType: ChainTypeEnum | "";
   public networkAPIs: NetworkAPIs;
 
-  public constructor(networkAPIs: NetworkAPIs, chainType?: ChainTypes) {
+  public constructor(networkAPIs: NetworkAPIs, chainType?: ChainTypeEnum) {
     this.chainType = chainType || "";
     this.networkAPIs = networkAPIs;
   }
 
-  public setChainType(chainType: ChainTypes): void {
+  public setChainType(chainType: ChainTypeEnum): void {
     this.chainType = chainType;
   }
 
-  public async getNetworks(chainType?: ChainTypes | ""): Promise<INetwork[]> {
+  public async getNetworks(chainType?: ChainTypeEnum | ""): Promise<INetwork[]> {
     const networks = this.networkAPIs.getAllNetworks(chainType || "");
     return networks;
   }

package/src/base/transaction.ts

@@ -1,14 +1,14 @@
 import { TransactionAPIs } from "../api/transaction";
 import { QueryGasParams } from "../types";
 
-import { ChainTypes } from "@tomo-inc/wallet-utils";
-const MYDOGE_PLATFORM_IN_SERVICE = 4;
+// import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
+// const MYDOGE_PLATFORM_IN_SERVICE = 4;
 
-const notSupportChainTypes = {
-  [ChainTypes.BTC]: true,
-  [ChainTypes.COSMOS]: true,
-  [ChainTypes.DOGE]: true,
-};
+// const notSupportChainTypes = {
+//   [ChainTypeEnum.BITCOIN]: true,
+//   [ChainTypeEnum.COSMOS]: true,
+//   [ChainTypeEnum.DOGECOIN]: true,
+// };
 
 //src/background/services/socials/tomo.ts
 export class Transactions {

package/src/dogecoin/config.ts

@@ -1,6 +1,6 @@
-import { ChainTypes, SupportedChainTypes } from "@tomo-inc/wallet-utils";
+import { ChainTypeEnum, SupportedChainTypes } from "@tomo-inc/wallet-utils";
 
-export const BaseConfig = SupportedChainTypes[ChainTypes.DOGE] as any;
+export const BaseConfig = SupportedChainTypes[ChainTypeEnum.DOGE] as any;
 
 export const BLOCK_CONFIRMATIONS = 1;
 export const FEE_RATE_KB = 0.5;

package/src/dogecoin/service.ts

@@ -1,35 +1,35 @@
-import { ChainTypes } from "@tomo-inc/wallet-utils";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
 
 import { BaseService } from "../base/service";
 
 import { BigNumber } from "bignumber.js";
-import { DogecoinUtils } from "./utils-doge";
 import { parseUnits, toHex } from "viem";
+import { DogecoinUtils } from "./utils-doge";
 
 import { IAccountInfo, QueryGasParams, QueryGasResponse, TomoAppInfo } from "../types";
 import { TransactionParams } from "./type";
 
+import * as base from "./base";
 import * as API from "./rpc";
-import * as utils from "./utils";
 import { DogeTxData } from "./type";
-import * as base from "./base";
+import * as utils from "./utils";
 
 import { BaseConfig } from "./config";
-import { createPsbt, addUsedUtxos, toBitcoin } from "./utils";
+import { addUsedUtxos, createPsbt, toBitcoin } from "./utils";
 
 export class DogecoinService extends BaseService {
   private static instance: DogecoinService;
-  public chainType: ChainTypes | "";
+  public chainType: ChainTypeEnum | "";
   public rpcService: typeof API;
 
-  public constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
+  public constructor(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
     super(tomoAppInfo, accountInfo);
     this.chainType = chainType;
     this.rpcService = API;
   }
 
   //singleton
-  public static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
+  public static getInstance(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
     if (!DogecoinService.instance) {
       DogecoinService.instance = new DogecoinService(chainType, accountInfo, tomoAppInfo);
     }

package/src/evm/service.ts

@@ -1,4 +1,4 @@
-import { ChainTypes, SupportedChainTypes } from "@tomo-inc/wallet-utils";
+import { ChainTypeEnum, SupportedChainTypes } from "@tomo-inc/wallet-utils";
 import { BigNumber } from "bignumber.js";
 import {
   createPublicClient,
@@ -31,14 +31,14 @@ import { createErc20TxData, getAllTypeChainIds, isEvmChain } from "./utils";
 
 export class EvmService extends BaseService {
   private static instance: EvmService;
-  public chainType: ChainTypes | "";
+  public chainType: ChainTypeEnum | "";
 
-  public constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
+  public constructor(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
     super(tomoAppInfo, accountInfo);
     this.chainType = chainType;
   }
 
-  public static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
+  public static getInstance(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
     if (!EvmService.instance) {
       EvmService.instance = new EvmService(chainType, accountInfo, tomoAppInfo);
     }
@@ -67,7 +67,7 @@ export class EvmService extends BaseService {
   }
 
   private async getCurrentChain(): Promise<INetwork> {
-    this.networks.setChainType(this.chainType as ChainTypes);
+    this.networks.setChainType(this.chainType as ChainTypeEnum);
     const currentNetwork = await this.networks.getCurrentNetwork();
     return currentNetwork;
   }
@@ -166,7 +166,7 @@ export class EvmService extends BaseService {
     if (!success) {
       console.error("queryGasInfo evm", txData, queryGasParams, message, gasInfo);
 
-      const BaseConfig = SupportedChainTypes[ChainTypes.EVM];
+      const BaseConfig = SupportedChainTypes[ChainTypeEnum.EVM];
       const { gasFee } = BaseConfig;
       return {
         success: true,
@@ -174,7 +174,7 @@ export class EvmService extends BaseService {
       };
     }
 
-    const nativeChainId = SupportedChainTypes[this.chainType as ChainTypes].chainId as string;
+    const nativeChainId = SupportedChainTypes[this.chainType as ChainTypeEnum].chainId as string;
     const { nativeCurrency } = await this.networks.getNetworkByChainId(nativeChainId);
 
     const { baseFee = 1, gasLimit = 0 } = gasInfo;
@@ -210,7 +210,7 @@ export class EvmService extends BaseService {
       });
     }
     if (chainId) {
-      this.networks.setChainType(this.chainType as ChainTypes);
+      this.networks.setChainType(this.chainType as ChainTypeEnum);
       const chainInfo: any = await this.networks.getNetworkByChainId(chainId);
       rpcUrl = chainInfo.rpcUrls[0];
     } else {
@@ -243,7 +243,7 @@ export class EvmService extends BaseService {
       console.warn("Failed to estimate gas:", error);
       // throw new Error(`Failed to estimate gas: ${error}`);
 
-      const BaseConfig = SupportedChainTypes[ChainTypes.EVM];
+      const BaseConfig = SupportedChainTypes[ChainTypeEnum.EVM];
       const { gasFee } = BaseConfig;
       return numberToHex(parseUnits(gasFee.toString(), 18));
     }

package/src/index.ts

@@ -1,4 +1,4 @@
-import { ChainTypes } from "@tomo-inc/wallet-utils";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
 import { DogecoinService } from "./dogecoin/service";
 import { EvmService } from "./evm/service";
 import { SolanaService } from "./solana/service";
@@ -6,9 +6,9 @@ import { SolanaService } from "./solana/service";
 export { DogecoinService, EvmService, SolanaService };
 
 export const ChainTypeServices = {
-  [ChainTypes.EVM]: EvmService,
-  [ChainTypes.SOL]: SolanaService,
-  [ChainTypes.DOGE]: DogecoinService,
+  [ChainTypeEnum.EVM]: EvmService,
+  [ChainTypeEnum.SOLANA]: SolanaService,
+  [ChainTypeEnum.DOGECOIN]: DogecoinService,
 };
 
 export { TomoWallet } from "./wallet";

package/src/solana/config.ts

@@ -1,5 +1,5 @@
-import { ChainTypes, SupportedChainTypes } from "@tomo-inc/wallet-utils";
-export const BaseConfig = SupportedChainTypes[ChainTypes.SOL] as any;
+import { ChainTypeEnum, SupportedChainTypes } from "@tomo-inc/wallet-utils";
+export const BaseConfig = SupportedChainTypes[ChainTypeEnum.SOL] as any;
 
 export const TOKEN_METADATA_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
 export const MSG_PREFIX = "\xffsolana offchain";

package/src/solana/service.ts

@@ -1,4 +1,4 @@
-import { ChainTypes, SupportedChainTypes, TomoApiDomains } from "@tomo-inc/wallet-utils";
+import { ChainTypeEnum, SupportedChainTypes, TomoApiDomains } from "@tomo-inc/wallet-utils";
 
 import { BaseService } from "../base/service";
 
@@ -16,11 +16,11 @@ import * as base from "../dogecoin/base";
 
 export class SolanaService extends BaseService {
   private static instance: SolanaService;
-  public chainType: ChainTypes | "";
+  public chainType: ChainTypeEnum | "";
   public rpcUrl: string;
   private connection: Connection;
 
-  public constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
+  public constructor(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
     super(tomoAppInfo, accountInfo);
     this.chainType = chainType;
     const config: any = {
@@ -38,7 +38,7 @@ export class SolanaService extends BaseService {
     this.connection = new Connection(rpcUrl, config);
   }
 
-  public static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
+  public static getInstance(chainType: ChainTypeEnum, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
     if (!SolanaService.instance) {
       SolanaService.instance = new SolanaService(chainType, accountInfo, tomoAppInfo);
     }
@@ -131,7 +131,7 @@ export class SolanaService extends BaseService {
       };
     }
 
-    const nativeChainId = SupportedChainTypes[this.chainType as ChainTypes].chainId as string;
+    const nativeChainId = SupportedChainTypes[this.chainType as ChainTypeEnum].chainId as string;
     const { nativeCurrency } = await this.networks.getNetworkByChainId(nativeChainId);
 
     const { baseFee = 1, gasLimit = 0 } = gasInfo;

package/src/types/account.ts

@@ -1,4 +1,4 @@
-import { ChainTypes } from "@tomo-inc/wallet-utils";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
 
 export interface WalletAccountItem {
   addresses: object[];
@@ -35,7 +35,7 @@ export interface IAccount {
   readonly type: AccountType;
   readonly lastUsedTime?: number;
   readonly sortIndex?: number;
-  readonly addresses: Record<ChainTypes, ChainAddress[]>;
+  readonly addresses: Record<ChainTypeEnum, ChainAddress[]>;
 
   readonly mnemonic: string | null;
   readonly addressIndex: number;

package/src/types/network.ts

@@ -1,4 +1,4 @@
-import { ChainTypes } from "@tomo-inc/wallet-utils";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
 
 export type NativeCurrency = {
   symbol: string;
@@ -21,13 +21,13 @@ 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}`;
+  | `${ChainTypeEnum.EVM}:${EVMNetwork}`
+  | `${ChainTypeEnum.BITCOIN}:${BTCNetwork}`
+  | `${ChainTypeEnum.SOLANA}:${SolNetwork}`
+  | `${ChainTypeEnum.SUI}:${SuiNetwork}`
+  | `${ChainTypeEnum.DOGECOIN}:${DogeNetwork}`
+  | `${ChainTypeEnum.TON}:${TonNetwork}`
+  | `${ChainTypeEnum.TRON}:${TronNetwork}`;
 
 export interface RemoteChainInfo2 {
   chainId: number;

package/src/types/wallet.ts

@@ -1,4 +1,4 @@
-import { ChainTypes } from "@tomo-inc/wallet-utils";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
 
 export enum TxTypes {
   swap = 1,
@@ -20,7 +20,7 @@ export interface TransactionsParams {
 }
 
 export interface TransactionItem {
-  chainType: ChainTypes;
+  chainType: ChainTypeEnum;
   chainInfo: {
     chainId: string;
     name: string;

package/src/wallet.ts

@@ -1,8 +1,8 @@
 //types
-import { ChainTypes, getExplorerUrl } from "@tomo-inc/wallet-utils";
+import { ChainTypeEnum, getExplorerUrl } from "@tomo-inc/wallet-utils";
 
-import { INetwork, NativeCurrency, TomoAppInfo, TransactionsParams, TransactionsResponse } from "./types";
 import { BaseService } from "./base/service";
+import { INetwork, NativeCurrency, TomoAppInfo, TransactionsParams, TransactionsResponse } from "./types";
 
 export class TomoWallet extends BaseService {
   private static instance: TomoWallet;
@@ -20,19 +20,19 @@ export class TomoWallet extends BaseService {
     return new TomoWallet(walletId, tomoAppInfo);
   }
 
-  public async supportedChains(chainType?: ChainTypes | ""): Promise<INetwork[]> {
+  public async supportedChains(chainType?: ChainTypeEnum | ""): Promise<INetwork[]> {
     const networks = await this.networks.getNetworks(chainType || "");
     return networks;
   }
 
-  public async getChainInfo(chainType: ChainTypes, chainId: string): Promise<INetwork> {
+  public async getChainInfo(chainType: ChainTypeEnum, 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> {
+  public async isChainSupported(chainType: ChainTypeEnum, chainId: string): Promise<boolean> {
     this.networks.setChainType(chainType);
     const chainInfo = await this.networks.getNetworkByChainId(chainId);
     if (!chainInfo) {
@@ -72,7 +72,7 @@ export class TomoWallet extends BaseService {
         const chainIndex = item.chainIndex;
         const chainInfo = (await this.networks.getNetworkByChainIndex(chainIndex)) as INetwork;
         return {
-          chainType: chainInfo.platformType.toLowerCase() as ChainTypes,
+          chainType: chainInfo.platformType.toLowerCase() as ChainTypeEnum,
           chainInfo: {
             chainId: chainInfo.chainId.toString(),
             name: chainInfo.name,