@tomo-inc/chains-service 0.0.6 → 0.0.8

package/dist/index.cjs

@@ -7,6 +7,7 @@ var axios = require('axios');
 var CryptoJS = require('crypto-js');
 var splToken = require('@solana/spl-token');
 var web3_js = require('@solana/web3.js');
+var bitcoinjsLib = require('bitcoinjs-lib');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -2804,18 +2805,18 @@ var Networks = class {
     return networks;
   }
   async getNetworkByChainId(chainId) {
-    const network = await this.networkAPIs.getNetworkByChainId(chainId);
-    if (!network) {
+    const network2 = await this.networkAPIs.getNetworkByChainId(chainId);
+    if (!network2) {
       throw new Error("Network not found");
     }
-    return network;
+    return network2;
   }
   async getNetworkByChainIndex(chainIndex) {
-    const network = await this.networkAPIs.getNetworkByChainIndex(chainIndex);
-    if (!network) {
+    const network2 = await this.networkAPIs.getNetworkByChainIndex(chainIndex);
+    if (!network2) {
       throw new Error("Network not found");
     }
-    return network;
+    return network2;
   }
   async getCurrentNetwork() {
     const chainType = this.chainType;
@@ -2838,8 +2839,8 @@ var Tokens = class {
   constructor(tokenService) {
     this.tokenAPIs = tokenService;
   }
-  async searchTokens({ chainIndex, query }) {
-    const { data: tokens = [] } = await this.tokenAPIs.queryRemoteTokens({ keyword: query || "", chainIndex });
+  async searchTokens({ chainIndex, keyword }) {
+    const { data: tokens = [] } = await this.tokenAPIs.queryRemoteTokens({ keyword, chainIndex });
     return tokens;
   }
   // public async addToken(tokenInfo: Omit<TokenInfo, "id">): Promise<TokenInfo> {
@@ -2847,10 +2848,8 @@ var Tokens = class {
   //   return tokenInfoData;
   // }
   async getTokenInfo({ address, chainIndex }) {
-    const {
-      data: { data: tokenInfo }
-    } = await this.tokenAPIs.getTokenInfo({ address, chainIndex });
-    return tokenInfo;
+    const res = await this.tokenAPIs.getTokenInfo({ address, chainIndex });
+    return res?.data?.data;
   }
   async getTokenRiskInfo(_params) {
     const { data: tokenRiskInfo } = await this.tokenAPIs.getTokenRisk(_params);
@@ -2980,7 +2979,7 @@ var BasePublicService = class {
     this.apiBase = publicApiBase;
     this.tomoAppInfo = tomoAppInfo;
     [this.tokenApi, this.txApi, this.walletApi].map(
-      (api, i) => api.interceptors.request.use((params) => {
+      (api2, i) => api2.interceptors.request.use((params) => {
         const { tokenBaseUrl, txBaseUrl, walletBaseUrl } = publicApiBase;
         params.baseURL = [tokenBaseUrl, txBaseUrl, walletBaseUrl][i];
         return signRequest(params, tomoAppInfo.tomoClientId, tomoAppInfo);
@@ -3021,10 +3020,15 @@ var TokenAPIs = class _TokenAPIs extends BasePublicService {
     }
   }
   async getTokenRisk(params) {
-    if (typeof params.chainIndex !== "number" || !params.tokenAddress) {
+    if (typeof params.chainIndex !== "number" || !params.address) {
       throw new Error("chainName or tokenAddress is required");
     }
-    const res = await this.tokenApi.post("/v1/market/risk/details", [params]);
+    const res = await this.tokenApi.post("/v1/market/risk/details", [
+      {
+        chainIndex: params.chainIndex,
+        tokenAddress: params.address
+      }
+    ]);
     return {
       success: res?.data?.code === "0",
       message: res?.data?.msg,
@@ -3112,10 +3116,10 @@ var TokenAPIs = class _TokenAPIs extends BasePublicService {
     }
   }
   async getTokenDetail(params) {
-    const { chainIndex, tokenAddress } = params;
+    const { chainIndex, address } = params;
     const res = await this.tokenApi.get(`/v1/market/token/detail`, {
       params: {
-        tokenAddress,
+        tokenAddress: address,
         chainIndex
       }
     });
@@ -3267,12 +3271,26 @@ var loadNetworks = (WALLET_DOMAIN) => {
       supportHistory: false
     },
     {
-      chainId: 221122420,
-      chainIndex: 22112242e3,
-      name: "DOGEOS_DEVNET",
-      chainName: "DogeOS Devnet",
+      chainId: 26888,
+      chainIndex: 2688800,
+      name: "ABCORE_TESTNET",
+      chainName: "AB Core Testnet",
+      rpcUrls: ["https://rpc.core.testnet.ab.org"],
+      blockExplorerUrl: "https://explorer.core.testnet.ab.org",
+      platformType: "EVM",
+      isTestnet: true,
+      icon: "/assets/ab.svg",
+      supportSwap: true,
+      supportGift: false,
+      supportHistory: true
+    },
+    {
+      chainId: 6281971,
+      chainIndex: 628197100,
+      name: "DOGEOS_TESTNET",
+      chainName: "DogeOS Testnet",
       rpcUrls: [`${WALLET_DOMAIN}/rpc/v1/doge_test`],
-      blockExplorerUrl: "https://blockscout.devnet.doge.xyz",
+      blockExplorerUrl: "https://rpc.testnet.dogeos.com",
       platformType: "EVM",
       isTestnet: true,
       icon: "/assets/dogeos.svg",
@@ -3894,7 +3912,7 @@ var BaseService = class {
     }
     const baseUrlConfig = CONFIG[tomoAppInfo.tomoStage];
     const { tokenAPIs, transactionAPIs, networkAPIs } = tomoPublicApiService(baseUrlConfig, tomoAppInfo);
-    this.accountInfo = accountInfo;
+    this.accountInfo = accountInfo || null;
     this.networks = new Networks(networkAPIs);
     this.tokens = new Tokens(tokenAPIs);
     this.transactions = new Transactions(transactionAPIs);
@@ -3904,8 +3922,8 @@ var BaseService = class {
     this.approveParams = params;
   }
 };
-function getRPCClient(network) {
-  const { chainId, name, rpcUrls, nativeCurrencyDecimals, nativeCurrencyName, nativeCurrencySymbol } = network;
+function getRPCClient(network2) {
+  const { chainId, name, rpcUrls, nativeCurrencyDecimals, nativeCurrencyName, nativeCurrencySymbol } = network2;
   const myCustomChain = {
     id: Number(chainId) || chainId,
     name,
@@ -3960,8 +3978,8 @@ var TxTypes = /* @__PURE__ */ ((TxTypes2) => {
 })(TxTypes || {});
 
 // src/evm/utils.ts
-var isEvmChain = (network) => {
-  return network && network?.platformType === "EVM";
+var isEvmChain = (network2) => {
+  return network2 && network2?.platformType === "EVM";
 };
 var getAllTypeChainIds = ({ chainId, chainType }) => {
   if (viem.isHex(chainId)) {
@@ -4053,7 +4071,7 @@ var EvmService = class _EvmService extends BaseService {
   }
   async personal_sign([message, address]) {
     const accounts = await this.accountInfo.getCurrent();
-    if (accounts[0].address !== address) {
+    if (!viem.isAddressEqual(accounts[0].address, address)) {
       throw new Error("address is not the current account");
     }
     const signature = await this.accountInfo.signMessage(message);
@@ -4061,7 +4079,7 @@ var EvmService = class _EvmService extends BaseService {
   }
   async eth_signTypedData_v4([address, typedData]) {
     const accounts = await this.accountInfo.getCurrent();
-    if (accounts[0].address !== address) {
+    if (!viem.isAddressEqual(accounts[0].address, address)) {
       throw new Error("address is not the current account");
     }
     const signature = await this.accountInfo.signTypedData(typedData);
@@ -4069,7 +4087,7 @@ var EvmService = class _EvmService extends BaseService {
   }
   async eth_getBalance([address, type]) {
     const accounts = await this.accountInfo.getCurrent();
-    if (accounts[0].address !== address) {
+    if (!viem.isAddressEqual(accounts[0].address, address)) {
       throw new Error("address is not the current account");
     }
     if (type !== "latest") {
@@ -4113,8 +4131,8 @@ var EvmService = class _EvmService extends BaseService {
     });
     if (!success) {
       console.error("queryGasInfo evm", txData, queryGasParams, message, gasInfo);
-      const BaseConfig2 = walletUtils.SupportedChainTypes[walletUtils.ChainTypes.EVM];
-      const { gasFee } = BaseConfig2;
+      const BaseConfig3 = walletUtils.SupportedChainTypes[walletUtils.ChainTypes.EVM];
+      const { gasFee } = BaseConfig3;
       return {
         success: true,
         gasFee: gasFee.toString()
@@ -4146,51 +4164,6 @@ var EvmService = class _EvmService extends BaseService {
       }
     };
   }
-  async eth_estimateGas(txs) {
-    const { from, to, value = "0x1" } = txs[0] || {};
-    const accounts = await this.accountInfo.getCurrent();
-    if (accounts[0].address !== from) {
-      throw new Error("address is not the current account");
-    }
-    if (!to) {
-      throw new Error("to is not set");
-    }
-    const chainId = txs[0]?.chainId || await this.eth_chainId();
-    const queryGasParams = {
-      chainIndex: Number(chainId),
-      callData: "0x",
-      gasLimitParam: {
-        from,
-        to,
-        value
-      },
-      addressList: [from]
-    };
-    const chainType = this.chainType;
-    const {
-      data: gasInfo,
-      success,
-      message
-    } = await this.transactions.queryGasInfo({
-      chainType,
-      params: queryGasParams
-    });
-    if (!success) {
-      console.error("queryGasInfo evm", txs, message, gasInfo);
-      const { gasFee } = walletUtils.SupportedChainTypes[chainType];
-      return gasFee.toString();
-    }
-    const res = getAllTypeChainIds({ chainId, chainType });
-    const { nativeCurrencyDecimals } = await this.networks.getNetworkByChainId(res.chainId);
-    const { baseFee = 1, gasLimit = 0 } = gasInfo;
-    const baseFeeBN = new Bignumber.BigNumber(baseFee);
-    const calcFee = (feeLevel) => {
-      const fee = baseFeeBN.plus(gasInfo[feeLevel] || 0);
-      const gasFee = fee.times(gasLimit);
-      return viem.toHex(BigInt(gasFee.toNumber()), nativeCurrencyDecimals);
-    };
-    return calcFee("priorityFeeMedium");
-  }
   async createPublicClient({ chainId, rpcUrl }) {
     if (rpcUrl) {
       return viem.createPublicClient({
@@ -4212,6 +4185,26 @@ var EvmService = class _EvmService extends BaseService {
       transport: viem.http(rpcUrl)
     });
   }
+  async eth_estimateGas(txs) {
+    const { from, to, value = "0x1", chainId } = txs[0] || {};
+    const accounts = await this.accountInfo.getCurrent();
+    if (accounts[0].address !== from) {
+      throw new Error("address is not the current account");
+    }
+    if (!to) {
+      throw new Error("to is not set");
+    }
+    try {
+      const rpcClient = await this.createPublicClient({ chainId: chainId?.toString() });
+      const gas = await rpcClient.estimateGas({ account: from, to, value: viem.hexToBigInt(value) });
+      return gas;
+    } catch (error) {
+      console.warn("Failed to estimate gas:", error);
+      const BaseConfig3 = walletUtils.SupportedChainTypes[walletUtils.ChainTypes.EVM];
+      const { gasFee } = BaseConfig3;
+      return viem.numberToHex(viem.parseUnits(gasFee.toString(), 18));
+    }
+  }
   // Get nonce for current account
   async eth_getTransactionCount([address, type]) {
     const accounts = await this.accountInfo.getCurrent();
@@ -4240,30 +4233,35 @@ var EvmService = class _EvmService extends BaseService {
       nonce: "number",
       maxPriorityFeePerGas: "bigint",
       maxFeePerGas: "bigint",
-      gasLimit: "bigint",
+      gasPrice: "bigint",
       gas: "bigint"
     };
-    let txData = txParams?.[0];
-    const gas = txData?.gas || txData?.gasLimit;
-    txData = { ...txData, gas, gasLimit: gas };
+    const txData = txParams?.[0];
+    txData.gas = txData?.gas || txData?.gasLimit;
     txData.data = txData.data || "0x";
+    txData.value = txData.value || "0x";
+    txData.nonce = txData.nonce || "0x0";
+    if (!txData?.gas || !txData?.to || !txData?.chainId) {
+      throw new Error("gas or to or chainId is not set");
+    }
     const accounts = await this.accountInfo.getCurrent();
     const address = accounts[0].address;
-    if (txData?.from && txData?.from !== address) {
+    if (txData?.from && !viem.isAddressEqual(txData?.from, address)) {
       console.error("eth_signTransaction error data: from is not the current account", txData);
       throw new Error(`eth_signTransaction error data: from is not the current account`);
     }
     delete txData?.from;
+    delete txData?.gasLimit;
     const preparedTx = {
-      type: "eip1559",
-      gas: txData?.gasLimit,
-      account: address
+      gas: txData?.gas
     };
     for (const key in preparedTxPropsType) {
-      if (!txData?.[key] || !viem.isHex(txData?.[key])) {
-        throw new Error(`${key}: no data or wrong type`);
+      if (txData?.[key] && viem.isHex(txData?.[key])) {
+        preparedTx[key] = preparedTxPropsType[key] === "number" ? viem.fromHex(txData[key], "number") : txData[key];
       }
-      preparedTx[key] = preparedTxPropsType[key] === "number" ? viem.fromHex(txData[key], "number") : txData[key];
+    }
+    if (txData?.type !== "legacy") {
+      delete preparedTx.gasPrice;
     }
     try {
       const serializedTransaction = await this.accountInfo.signTransaction(
@@ -4386,6 +4384,34 @@ async function createTokenLegacyTransaction2({
 }
 
 // src/dogecoin/base.ts
+function fromHex3(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const paddedHex = cleanHex.length % 2 === 0 ? cleanHex : "0" + cleanHex;
+  const bytes = new Uint8Array(paddedHex.length / 2);
+  for (let i = 0; i < paddedHex.length; i += 2) {
+    bytes[i / 2] = parseInt(paddedHex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+function toHex3(data) {
+  if (typeof data === "string") {
+    return data.startsWith("0x") ? data.slice(2) : data;
+  }
+  const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+  return buffer.toString("hex");
+}
+function toBase64(data) {
+  if (typeof data === "string") {
+    const buffer2 = Buffer.from(data, "hex");
+    return buffer2.toString("base64");
+  }
+  const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+  return buffer.toString("base64");
+}
+function fromBase64(base64) {
+  const buffer = Buffer.from(base64, "base64");
+  return new Uint8Array(buffer);
+}
 function toBase58(data) {
   throw new Error("toBase58 requires bs58 package. Install it: pnpm add bs58");
 }
@@ -4422,11 +4448,11 @@ var SolanaService = class _SolanaService extends BaseService {
     return await this.accountInfo.getCurrent();
   }
   async getAccount() {
-    const { currentAddress, publicKey } = await this.accountInfo.getIds();
+    const { address: currentAddress, publicKey } = await this.accountInfo.getCurrent();
     return { publicKey: publicKey || currentAddress, address: currentAddress };
   }
   async signMessage(params) {
-    const { currentAddress, publicKey } = await this.accountInfo.getIds();
+    const { address: currentAddress, publicKey } = await this.accountInfo.getCurrent();
     const { message } = params;
     const signature = await this.accountInfo.signMessage(message);
     return {
@@ -4436,7 +4462,7 @@ var SolanaService = class _SolanaService extends BaseService {
     };
   }
   async signIn(params) {
-    const { currentAddress, publicKey } = await this.accountInfo.getIds();
+    const { address: currentAddress, publicKey } = await this.accountInfo.getCurrent();
     const { signature = "" } = await this.signMessage(params);
     return {
       address: currentAddress,
@@ -4627,6 +4653,486 @@ var SolanaService = class _SolanaService extends BaseService {
     }
   }
 };
+var BaseConfig2 = walletUtils.SupportedChainTypes[walletUtils.ChainTypes.DOGE];
+var DECIMALS = 1e8;
+var MYDOGE_BASE_URL = "https://api.mydoge.com";
+var RPC_URL = "https://api.bitcore.io/api/DOGE/mainnet";
+var RPC_TIMEOUT = 20 * 1e3;
+var network = {
+  messagePrefix: "Dogecoin Signed Message:\n",
+  bech32: "dc",
+  bip44: 3,
+  bip32: {
+    public: 49990397,
+    private: 49988504
+  },
+  pubKeyHash: 30,
+  scriptHash: 22,
+  wif: 158
+};
+
+// src/dogecoin/utils-doge.ts
+var DogecoinUtils = class {
+  /**
+   * Build the PSBT from the transaction
+   * @param tx utxoTx
+   * @param _maximumFeeRate number (optional, currently unused)
+   * @returns base64
+   */
+  static buildPsbtToBase64(tx, _maximumFeeRate) {
+    const psbt = new bitcoinjsLib.Psbt({ network });
+    for (const input of tx.inputs) {
+      const inputOptions = {
+        hash: input.txId,
+        index: input.vOut
+      };
+      if (input.nonWitnessUtxo) {
+        inputOptions.nonWitnessUtxo = Buffer.from(input.nonWitnessUtxo, "hex");
+      }
+      psbt.addInput(inputOptions);
+    }
+    for (const output of tx.outputs) {
+      psbt.addOutput({
+        value: output.amount,
+        address: output.address
+      });
+    }
+    const psbtHex = psbt.toHex();
+    return toBase64(fromHex3(psbtHex));
+  }
+  /**
+   * Extract the transaction from the signed PSBT
+   * @param signedPsbt base64
+   * @param _maximumFeeRate number (optional, currently unused)
+   * @returns transaction hex
+   */
+  static extractPsbtTransaction(signedPsbt, _maximumFeeRate) {
+    const signedPsbtHex = toHex3(fromBase64(signedPsbt));
+    const psbt = bitcoinjsLib.Psbt.fromHex(signedPsbtHex, {
+      network
+    });
+    const maximumFeeRate = _maximumFeeRate || 1e5;
+    psbt.setMaximumFeeRate(maximumFeeRate);
+    psbt.finalizeAllInputs();
+    const transaction = psbt.extractTransaction();
+    return transaction.toHex();
+  }
+  /**
+   * Convert raw transaction hex to PSBT base64
+   * This method converts an unsigned raw transaction to PSBT format.
+   * Note: The rawTx should be an unsigned transaction, and the nonWitnessUtxo
+   * for each input will need to be fetched separately from the blockchain.
+   * @param rawTx hex string of the raw transaction
+   * @returns base64 string of the PSBT
+   */
+  static async rawTxToPsbtBase64(rawTx) {
+    try {
+      const cleanHex = rawTx.startsWith("0x") ? rawTx.slice(2) : rawTx;
+      const transaction = bitcoinjsLib.Transaction.fromHex(cleanHex);
+      const psbt = new bitcoinjsLib.Psbt({ network });
+      for (let i = 0; i < transaction.ins.length; i++) {
+        const input = transaction.ins[i];
+        const hash = Buffer.from(input.hash).reverse().toString("hex");
+        const index = input.index;
+        const inputOptions = {
+          hash,
+          index,
+          nonWitnessUtxo: input.script
+        };
+        psbt.addInput(inputOptions);
+      }
+      for (const output of transaction.outs) {
+        try {
+          const address = bitcoinjsLib.address.fromOutputScript(output.script, network);
+          psbt.addOutput({
+            address,
+            value: Number(output.value)
+          });
+        } catch (error) {
+          psbt.addOutput({
+            script: output.script,
+            value: Number(output.value)
+          });
+        }
+      }
+      const psbtHex = psbt.toHex();
+      return toBase64(fromHex3(psbtHex));
+    } catch (error) {
+      console.warn("rawTxToPsbtBase64 failed:", error);
+      throw new Error(
+        `Failed to convert raw transaction to PSBT: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+};
+var KOINU_PER_DOGE = new Bignumber.BigNumber(DECIMALS);
+function toSatoshi(bitcion) {
+  try {
+    const amount = new Bignumber.BigNumber(bitcion);
+    if (amount.isNaN() || amount.isNegative()) {
+      throw new Error("Invalid amount");
+    }
+    return amount.times(KOINU_PER_DOGE).integerValue(Bignumber.BigNumber.ROUND_DOWN).toNumber();
+  } catch (error) {
+    throw new Error(`toSatoshi failed: ${error.message}`);
+  }
+}
+function toBitcoin(satoshis) {
+  try {
+    const amount = new Bignumber.BigNumber(satoshis);
+    if (amount.isNaN() || amount.isNegative()) {
+      throw new Error("Invalid Koinu amount");
+    }
+    return amount.dividedBy(KOINU_PER_DOGE).toNumber();
+  } catch (error) {
+    throw new Error(`toBitcoin failed: ${error.message}`);
+  }
+}
+function addUsedUtxos(newUsedUtxos) {
+  const usedUtxos = walletUtils.cache.get("UsedUtxos") || {};
+  for (const txid in newUsedUtxos) {
+    usedUtxos[txid] = 1;
+  }
+  walletUtils.cache.set("UsedUtxos", usedUtxos, false);
+}
+async function createPsbt({
+  from,
+  to,
+  amount,
+  fee,
+  spendableUtxos
+}) {
+  const utxos = spendableUtxos;
+  if (!utxos || utxos.length === 0) {
+    throw new Error("no spendable utxos");
+  }
+  const sendAmount = toSatoshi(amount);
+  const sendCost = toSatoshi(fee);
+  const totalNeeded = sendAmount + sendCost;
+  const sortedUtxos = utxos.sort((a, b) => b.outputValue - a.outputValue);
+  const selectedUtxos = [];
+  let accumulatedAmount = 0;
+  for (const utxo of sortedUtxos) {
+    if (accumulatedAmount >= totalNeeded) break;
+    selectedUtxos.push(utxo);
+    accumulatedAmount += Number(utxo.outputValue);
+  }
+  if (accumulatedAmount < totalNeeded) {
+    throw new Error("not enough funds to cover amount and fee");
+  }
+  const utxoDetailPromises = selectedUtxos.map(async (utxo) => {
+    try {
+      const utxoDetail = await getTxDetail(utxo.txid);
+      return { utxo, utxoDetail };
+    } catch (error) {
+      return { utxo, utxoDetail: null };
+    }
+  });
+  const utxoResults = await Promise.all(utxoDetailPromises);
+  const inputs = [];
+  const usingUtxos = {};
+  let addedAmount = 0;
+  for (const { utxo, utxoDetail } of utxoResults) {
+    if (addedAmount >= totalNeeded) break;
+    const { txid, vout, outputValue, address = from } = utxo;
+    if (utxoDetail?.hex && !usingUtxos[txid]) {
+      inputs.push({
+        txId: txid,
+        vOut: vout,
+        amount: Number(outputValue),
+        nonWitnessUtxo: utxoDetail.hex,
+        address
+      });
+      usingUtxos[txid] = 1;
+      addedAmount += Number(outputValue);
+    }
+  }
+  if (addedAmount < totalNeeded) {
+    throw new Error("not enough funds to cover amount and fee");
+  }
+  const outputs = [
+    {
+      address: to,
+      amount: sendAmount
+    }
+  ];
+  const changeAmount = addedAmount - sendAmount - sendCost;
+  if (changeAmount > 0) {
+    outputs.push({
+      address: from,
+      amount: changeAmount
+    });
+  }
+  const params = {
+    address: from,
+    inputs,
+    outputs
+  };
+  const psbtBase64 = DogecoinUtils.buildPsbtToBase64(params);
+  return { psbtBase64, usingUtxos };
+}
+var mydoge = axios__default.default.create({
+  baseURL: MYDOGE_BASE_URL
+});
+var api = axios__default.default.create({
+  baseURL: RPC_URL,
+  timeout: RPC_TIMEOUT
+});
+async function getBalance(address) {
+  if (!address) {
+    return {
+      address: "",
+      balance: 0
+    };
+  }
+  const path = `/address/${address}?page=1&pageSize=10`;
+  const api2 = `${MYDOGE_BASE_URL}/wallet/info?route=` + encodeURIComponent(path);
+  const res = await mydoge.get(api2);
+  return res.data || {};
+}
+async function getTxDetail(txId) {
+  if (!txId) {
+    return {};
+  }
+  const path = `/tx/${txId}`;
+  const api2 = `${MYDOGE_BASE_URL}/wallet/info?route=` + encodeURIComponent(path);
+  const res = await mydoge.get(api2);
+  return res.data || {};
+}
+var Drc20DetailsCacheKey = "Drc20Details";
+walletUtils.cache.get(Drc20DetailsCacheKey) || {};
+async function getUtxos(address, cursor, result, filter, tx = null) {
+  const query = (await mydoge.get(`${MYDOGE_BASE_URL}/utxos/${address}?filter=${filter}${cursor ? `&cursor=${cursor}` : ""}`)).data;
+  let { utxos } = query;
+  if (tx) {
+    utxos = utxos.filter((utxo) => utxo.txid === tx?.txid && utxo.vout === tx?.vout);
+  }
+  result.push(
+    ...utxos.map((i) => ({
+      txid: i.txid,
+      vout: i.vout,
+      outputValue: i.satoshis,
+      script: i.script_pubkey,
+      ...filter === "inscriptions"
+    }))
+  );
+  if (result.length && tx) {
+    return;
+  }
+  result = result.sort((a, b) => toBitcoin(b.outputValue) - toBitcoin(a.outputValue));
+  if (query.next_cursor) {
+    return getUtxos(address, query.next_cursor, result, filter, tx);
+  }
+}
+async function getSpendableUtxos(address) {
+  const utxos = [];
+  await getUtxos(address, 0, utxos, "spendable");
+  return utxos;
+}
+var DuneDetailsCacheKey = "DuneDetails";
+walletUtils.cache.get(DuneDetailsCacheKey) || {};
+var sendDogeTx = async (rawTx) => {
+  try {
+    const res = await api.post("/tx/send", { rawTx });
+    return res.data;
+  } catch (e) {
+    if (typeof e?.response?.data === "string") return Promise.reject(e?.response?.data);
+    else return Promise.reject(e.message);
+  }
+};
+
+// src/dogecoin/service.ts
+var DogecoinService = class _DogecoinService extends BaseService {
+  static instance;
+  chainType;
+  constructor(chainType, accountInfo, tomoAppInfo) {
+    super(tomoAppInfo, accountInfo);
+    this.chainType = chainType;
+  }
+  //singleton
+  static getInstance(chainType, accountInfo, tomoAppInfo) {
+    if (!_DogecoinService.instance) {
+      _DogecoinService.instance = new _DogecoinService(chainType, accountInfo, tomoAppInfo);
+    }
+    return _DogecoinService.instance;
+  }
+  async requestAccounts() {
+    const addresses = await this.accountInfo.getCurrent();
+    const { publicKey, address } = addresses?.[0] || {};
+    if (!address) {
+      throw new Error("address is not set");
+    }
+    const { balance = 0 } = await getBalance(address);
+    return {
+      address,
+      balance,
+      approved: true,
+      publicKey
+    };
+  }
+  async getAccounts() {
+    const accounts = await this.accountInfo.getCurrent();
+    return accounts.map((account) => account.address);
+  }
+  async getConnectionStatus() {
+    const addresses = await this.accountInfo.getCurrent();
+    const { address } = addresses?.[0] || {};
+    if (!address) {
+      throw new Error("address is not set");
+    }
+    return {
+      connected: true,
+      address,
+      selectedWalletAddress: address
+    };
+  }
+  async getBalance() {
+    const addresses = await this.accountInfo.getCurrent();
+    const { address } = addresses?.[0] || {};
+    if (!address) {
+      throw new Error("address is not set");
+    }
+    const { balance = 0 } = await getBalance(address);
+    return {
+      address,
+      balance
+    };
+  }
+  async signMessage({ message, type }) {
+    if (type) {
+      throw new Error("bip322simple not support.");
+    }
+    const signature = await this.accountInfo.signMessage(message);
+    return {
+      signedMessage: signature
+    };
+  }
+  async requestSignedMessage({
+    message,
+    type
+  }) {
+    return await this.signMessage({
+      message,
+      type
+    });
+  }
+  async requestDecryptedMessage({ message }) {
+    try {
+      if (!this.accountInfo?.decryptedMessage) {
+        throw new Error("decryptedMessage is not supported");
+      }
+      const unsignRes = await this.accountInfo?.decryptedMessage(message);
+      const { text = "" } = JSON.parse(unsignRes);
+      return {
+        decryptedMessage: text
+      };
+    } catch (err) {
+      throw new Error("requestDecryptedMessage err:" + JSON.stringify(err));
+    }
+  }
+  async _queryGasInfo(txData) {
+    const { chainId, amount = 0, decimals = 8 } = txData;
+    const gasLimitParam = {
+      from: txData.from,
+      to: txData.to,
+      value: viem.toHex(viem.parseUnits(amount.toString(), decimals))
+    };
+    const queryGasParams = {
+      chainIndex: Number(chainId || BaseConfig2.chainId),
+      callData: "0x",
+      gasLimitParam,
+      addressList: [txData.from]
+    };
+    const {
+      data: gasInfo,
+      success,
+      message
+    } = await this.transactions.queryGasInfo({
+      chainType: this.chainType,
+      params: queryGasParams
+    });
+    if (!success) {
+      console.error("queryGasInfo doge", success, txData, queryGasParams, gasInfo);
+      const { gasFee } = BaseConfig2;
+      return {
+        success: true,
+        gasFee: gasFee.toString()
+      };
+    }
+    const { baseFee = 1, gasLimit = 1 } = gasInfo;
+    const calcFee = (feeLevel) => {
+      const gasFee = new Bignumber.BigNumber(gasInfo[feeLevel] || baseFee).times(gasLimit);
+      return toBitcoin(gasFee.toNumber());
+    };
+    const fees = {
+      low: calcFee("priorityFeeLow"),
+      medium: calcFee("priorityFeeMedium"),
+      high: calcFee("priorityFeeHigh")
+    };
+    return {
+      success: true,
+      fees,
+      gasFee: fees.high
+    };
+  }
+  async requestPsbt({
+    rawTx,
+    signOnly
+  }) {
+    const psbtBase64 = await DogecoinUtils.rawTxToPsbtBase64(rawTx);
+    const signedPsbt = await this.accountInfo.signTransaction(JSON.stringify({ psbtBase64 }));
+    if (!signedPsbt) {
+      return null;
+    }
+    const signedRawTx = DogecoinUtils.extractPsbtTransaction(signedPsbt, 1e5);
+    if (signOnly) {
+      return {
+        signedRawTx
+      };
+    }
+    const { txid = "" } = await sendDogeTx(signedRawTx);
+    return {
+      txId: txid,
+      signedRawTx
+    };
+  }
+  async requestTransaction(txData) {
+    const spendableUtxos = txData?.spendableUtxos;
+    if (txData.amountMismatch) {
+      throw new Error("balance_insufficient");
+    }
+    if (!spendableUtxos || spendableUtxos?.length === 0) {
+      txData.spendableUtxos = await getSpendableUtxos(txData.from);
+    }
+    const { psbtBase64, usingUtxos } = await createPsbt(txData);
+    const signedPsbt = await this.accountInfo.signTransaction(JSON.stringify({ psbtBase64 }));
+    const signedTx = DogecoinUtils.extractPsbtTransaction(signedPsbt, 1e5);
+    if (signedTx === "") {
+      throw new Error("Error: sign transaction err.");
+    }
+    try {
+      const { txid } = await sendDogeTx(signedTx);
+      addUsedUtxos(usingUtxos);
+      return { txId: txid };
+    } catch (err) {
+      throw new Error("Error: send transaction err." + JSON.stringify(err));
+    }
+  }
+  async getTransactionStatus({ txId }) {
+    const transaction = await getTxDetail(txId);
+    if (!transaction?.txid) {
+      return null;
+    }
+    return {
+      txId: transaction.txid,
+      confirmations: transaction.confirmations,
+      status: transaction.confirmations > 0 ? "confirmed" : "pending",
+      dogeAmount: transaction.vout[0]?.value,
+      blockTime: transaction.blockTime,
+      address: transaction.vout[0]?.addresses[0]
+    };
+  }
+};
 var TomoWallet = class _TomoWallet extends BaseService {
   static instance;
   walletId;
@@ -4646,8 +5152,8 @@ var TomoWallet = class _TomoWallet extends BaseService {
   }
   async getChainInfo(chainType, chainId) {
     this.networks.setChainType(chainType);
-    const network = await this.networks.getNetworkByChainId(chainId);
-    return network;
+    const network2 = await this.networks.getNetworkByChainId(chainId);
+    return network2;
   }
   //evm chains
   async isChainSupported(chainType, chainId) {
@@ -4714,12 +5220,13 @@ var TomoWallet = class _TomoWallet extends BaseService {
 // src/index.ts
 var ChainTypeServices = {
   [walletUtils.ChainTypes.EVM]: EvmService,
-  [walletUtils.ChainTypes.SOL]: SolanaService
-  // [ChainTypes.DOGE]: DogecoinService,
+  [walletUtils.ChainTypes.SOL]: SolanaService,
+  [walletUtils.ChainTypes.DOGE]: DogecoinService
 };
 
 exports.AccountType = AccountType;
 exports.ChainTypeServices = ChainTypeServices;
+exports.DogecoinService = DogecoinService;
 exports.EvmService = EvmService;
 exports.SolanaService = SolanaService;
 exports.TomoWallet = TomoWallet;