@tomo-inc/chains-service 0.0.7 → 0.0.9

package/dist/index.js

@@ -1,10 +1,11 @@
 import { ChainTypes, SupportedChainTypes, TomoApiDomains, cache, getExplorerUrl } from '@tomo-inc/wallet-utils';
-import Bignumber, { BigNumber } from 'bignumber.js';
-import { toHex, parseUnits, createPublicClient, http, isHex, fromHex, parseTransaction, formatUnits, encodeFunctionData, erc20Abi } from 'viem';
 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 { getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction, TOKEN_PROGRAM_ID } from '@solana/spl-token';
-import { PublicKey, Connection, VersionedTransaction, sendAndConfirmRawTransaction, Transaction, SystemProgram, LAMPORTS_PER_SOL } from '@solana/web3.js';
+import { PublicKey, Connection, VersionedTransaction, sendAndConfirmRawTransaction, Transaction as Transaction$1, SystemProgram, LAMPORTS_PER_SOL } from '@solana/web3.js';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -15,6 +16,10 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -2796,18 +2801,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;
@@ -2830,8 +2835,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> {
@@ -2839,10 +2844,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);
@@ -2972,7 +2975,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);
@@ -3013,10 +3016,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,
@@ -3104,10 +3112,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
       }
     });
@@ -3259,12 +3267,40 @@ 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: 36888,
+      chainIndex: 3688800,
+      name: "ABCORE",
+      chainName: "AB Core",
+      rpcUrls: ["https://rpc1.core.ab.org"],
+      blockExplorerUrl: "https://explorer.core.ab.org",
+      platformType: "EVM",
+      isTestnet: false,
+      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",
@@ -3886,7 +3922,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);
@@ -3896,8 +3932,718 @@ var BaseService = class {
     this.approveParams = params;
   }
 };
-function getRPCClient(network) {
-  const { chainId, name, rpcUrls, nativeCurrencyDecimals, nativeCurrencyName, nativeCurrencySymbol } = network;
+
+// src/dogecoin/base.ts
+function fromHex(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 toHex(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");
+}
+var BaseConfig = SupportedChainTypes[ChainTypes.DOGE];
+var BLOCK_CONFIRMATIONS = 1;
+var FEE_RATE_KB = 0.5;
+var DECIMALS = 1e8;
+var TRANSACTION_PAGE_SIZE = 10;
+var MYDOGE_BASE_URL = "https://api.mydoge.com";
+var RPC_URL = "https://api.bitcore.io/api/DOGE/mainnet";
+var RPC_TIMEOUT = 20 * 1e3;
+var TX_OVERHEAD = 10;
+var P2SH_INPUT_SIZE = 148;
+var TX_OUTPUT_SIZE = 34;
+var DEFAULT_OUTPUT_COUNT = 2;
+var TX_SIZE = 1 * P2SH_INPUT_SIZE + DEFAULT_OUTPUT_COUNT * TX_OUTPUT_SIZE + TX_OVERHEAD;
+var network = {
+  messagePrefix: "Dogecoin Signed Message:\n",
+  bech32: "dc",
+  bip44: 3,
+  bip32: {
+    public: 49990397,
+    private: 49988504
+  },
+  pubKeyHash: 30,
+  scriptHash: 22,
+  wif: 158
+};
+
+// src/dogecoin/rpc.ts
+var rpc_exports = {};
+__export(rpc_exports, {
+  estimateSmartFee: () => estimateSmartFee,
+  getBalance: () => getBalance,
+  getDogeFeeByBlock: () => getDogeFeeByBlock,
+  getInscriptionsUtxo: () => getInscriptionsUtxo,
+  getInscriptionsUtxos: () => getInscriptionsUtxos,
+  getSpendableUtxos: () => getSpendableUtxos,
+  getTransactions: () => getTransactions,
+  getTxDetail: () => getTxDetail,
+  getUnSpentUtxos: () => getUnSpentUtxos,
+  mydoge: () => mydoge,
+  onCreateTransaction: () => onCreateTransaction,
+  sendDogeTx: () => sendDogeTx,
+  sendTransaction: () => sendTransaction
+});
+var KOINU_PER_DOGE = new BigNumber(DECIMALS);
+function toSatoshi(bitcion) {
+  try {
+    const amount = new BigNumber(bitcion);
+    if (amount.isNaN() || amount.isNegative()) {
+      throw new Error("Invalid amount");
+    }
+    return amount.times(KOINU_PER_DOGE).integerValue(BigNumber.ROUND_DOWN).toNumber();
+  } catch (error) {
+    throw new Error(`toSatoshi failed: ${error.message}`);
+  }
+}
+function toBitcoin(satoshis) {
+  try {
+    const amount = new 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 = cache.get("UsedUtxos") || {};
+  for (const txid in newUsedUtxos) {
+    usedUtxos[txid] = 1;
+  }
+  cache.set("UsedUtxos", usedUtxos, false);
+}
+function getUsedUtxos() {
+  return cache.get("UsedUtxos") || {};
+}
+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 };
+}
+function decodePsbt(psbt, type = "hex") {
+  try {
+    if (type === "base64") {
+      const psbtHex = toHex(fromBase64(psbt));
+      return Psbt.fromHex(psbtHex, {
+        network
+      });
+    }
+    return Psbt.fromHex(psbt, {
+      network
+    });
+  } catch (error) {
+    console.error("Failed to decode PSBT:", error);
+    throw error;
+  }
+}
+var TransactionParser = class {
+  rawTx;
+  constructor(rawTx) {
+    this.rawTx = rawTx;
+  }
+  hexToText(hex) {
+    let str = "";
+    for (let i = 0; i < hex.length; i += 2) {
+      str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+    }
+    return str;
+  }
+  extractOPReturnData() {
+    const ordIndex = this.rawTx.indexOf("6f7264");
+    if (ordIndex === -1) return null;
+    const dataHex = this.rawTx.substring(ordIndex);
+    const dataText = this.hexToText(dataHex);
+    const jsonMatch = dataText.match(/\{.*?\}/);
+    return jsonMatch ? JSON.parse(jsonMatch[0]) : null;
+  }
+  parseScript() {
+    return {
+      version: this.rawTx.substring(0, 8),
+      inputCount: parseInt(this.rawTx.substring(8, 10)),
+      inputs: this.parseInputs(),
+      opReturnData: this.extractOPReturnData()
+    };
+  }
+  parseInputs() {
+    const inputs = [];
+    const position = 10;
+    const firstInput = {
+      txid: this.rawTx.substring(position, position + 64),
+      vout: this.rawTx.substring(position + 64, position + 72),
+      scriptData: this.extractOPReturnData()
+    };
+    inputs.push(firstInput);
+    return inputs;
+  }
+};
+
+// src/dogecoin/rpc.ts
+var mydoge = axios.create({
+  baseURL: MYDOGE_BASE_URL
+});
+var api = axios.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 || {};
+}
+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" && { inscriptions: i.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 getInscriptionsUtxos(address) {
+  const inscriptions = [];
+  await getUtxos(address, 0, inscriptions, "inscriptions");
+  return inscriptions;
+}
+async function getSpendableUtxos(address) {
+  const utxos = [];
+  await getUtxos(address, 0, utxos, "spendable");
+  return utxos;
+}
+async function getUnSpentUtxos(address) {
+  try {
+    const result = await api.get(`/address/${address}/?unspent=true&limit=${0}`);
+    const unSpentUtxo = result?.data;
+    if (unSpentUtxo?.length) return unSpentUtxo.filter((utxo) => !utxo.spentTxid);
+    return [];
+  } catch (e) {
+    return [];
+  }
+}
+async function getInscriptionsUtxo(address, tx) {
+  const inscriptions = [];
+  await getUtxos(address, 0, inscriptions, "inscriptions", tx);
+  return inscriptions[0];
+}
+async function sendTransaction({ signed, senderAddress }) {
+  const jsonrpcReq = {
+    jsonrpc: "2.0",
+    id: `${senderAddress}_send_${Date.now()}`,
+    method: "sendrawtransaction",
+    params: [signed]
+  };
+  const jsonrpcRes = (await mydoge.post("/wallet/rpc", jsonrpcReq)).data;
+  return jsonrpcRes;
+}
+async function estimateSmartFee({ senderAddress }) {
+  const smartfeeReq = {
+    jsonrpc: "2.0",
+    id: `${senderAddress}_estimatesmartfee_${Date.now()}`,
+    method: "estimatesmartfee",
+    params: [BLOCK_CONFIRMATIONS]
+    // confirm within x blocks
+  };
+  const feeData = (await mydoge.post("/wallet/rpc", smartfeeReq)).data;
+  const feeRate = feeData?.result?.feerate || FEE_RATE_KB;
+  const feePerKB = toSatoshi(feeRate * 2);
+  return { feePerKB };
+}
+async function onCreateTransaction({ data, sendResponse }) {
+  const amountSatoshi = toSatoshi(data.dogeAmount);
+  const amount = toBitcoin(amountSatoshi);
+  try {
+    const response = await mydoge.post("/v3/tx/prepare", {
+      sender: data.senderAddress,
+      recipient: data.recipientAddress,
+      amount
+    });
+    const { rawTx, fee, amount: resultAmount } = response.data;
+    let amountMismatch = false;
+    if (resultAmount < amount - fee) {
+      amountMismatch = true;
+    }
+    sendResponse?.({
+      rawTx,
+      fee,
+      amount: resultAmount,
+      amountMismatch
+    });
+  } catch (err) {
+    sendResponse?.(false);
+  }
+}
+async function getTransactions(address, config) {
+  const { pageSize = 10, pageNumber = 1 } = config || {};
+  const size = Math.min(pageSize, TRANSACTION_PAGE_SIZE);
+  let txIds = [];
+  let totalPages;
+  let page;
+  try {
+    const response = (await mydoge.get("/wallet/info", {
+      params: {
+        route: `/address/${address}?page=${pageNumber}&pageSize=${size}`
+      }
+    })).data;
+    txIds = response.txids;
+    totalPages = response.totalPages;
+    page = response.page;
+    const transactions = await Promise.all(
+      txIds?.map(async (txId) => {
+        const detail = await getTxDetail(txId);
+        const tx = new TransactionParser(detail.hex);
+        const parsedData = tx.parseScript();
+        return {
+          ...detail,
+          tick: parsedData?.opReturnData?.tick,
+          tickAmount: parsedData?.opReturnData?.amt
+        };
+      }) || []
+    );
+    return { transactions, txIds, totalPages, page };
+  } catch (err) {
+    throw new Error("getTransactions failed");
+  }
+}
+var getDogeFeeByBlock = async (address, n = 22) => {
+  const res = await api.get(`/fee/${n}`);
+  return (res.data?.feerate || 0.01) * TX_SIZE;
+};
+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/utils-doge.ts
+var DogecoinAddress = class {
+  static network = network;
+  static generatePath(addressIndex) {
+    return `m/44'/3'/0'/0/${addressIndex || 0}`;
+  }
+  static verifyAddress(address$1) {
+    try {
+      const decoded = address.fromBase58Check(address$1);
+      return decoded.version === network.pubKeyHash || decoded.version === network.scriptHash;
+    } catch (error) {
+      return false;
+    }
+  }
+};
+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 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: BigInt(output?.amount || 0),
+        address: output.address
+      });
+    }
+    const psbtHex = psbt.toHex();
+    return toBase64(fromHex(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 = toHex(fromBase64(signedPsbt));
+    const psbt = 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 = Transaction.fromHex(cleanHex);
+      const psbt = new Psbt({ network });
+      for (let i = 0; i < transaction.ins.length; i++) {
+        const input = transaction.ins[i];
+        const hash = Buffer.from(input.hash).toString("hex");
+        const index = input.index;
+        const inputOptions = {
+          hash,
+          index
+        };
+        try {
+          const prevTxDetail = await getTxDetail(hash);
+          if (prevTxDetail?.hex) {
+            inputOptions.nonWitnessUtxo = Buffer.from(prevTxDetail.hex, "hex");
+          } else {
+            throw new Error(`Previous transaction ${hash} has no hex data`);
+          }
+        } catch (error) {
+          throw new Error(
+            `Failed to fetch previous transaction ${hash} for input #${i}. This is required for PSBT creation. Error: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        psbt.addInput(inputOptions);
+      }
+      for (const output of transaction.outs) {
+        try {
+          const address$1 = address.fromOutputScript(output.script, network);
+          psbt.addOutput({
+            address: address$1,
+            value: BigInt(output?.value || 0)
+          });
+        } catch (error) {
+          psbt.addOutput({
+            script: output.script,
+            value: BigInt(output?.value || 0)
+          });
+        }
+      }
+      const psbtHex = psbt.toHex();
+      return toBase64(fromHex(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 DogecoinService = class _DogecoinService extends BaseService {
+  static instance;
+  chainType;
+  rpcService;
+  constructor(chainType, accountInfo, tomoAppInfo) {
+    super(tomoAppInfo, accountInfo);
+    this.chainType = chainType;
+    this.rpcService = rpc_exports;
+  }
+  //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 _queryGasInfo(txData) {
+    const { chainId, amount = 0, decimals = 8 } = txData;
+    const gasLimitParam = {
+      from: txData.from,
+      to: txData.to,
+      value: toHex$1(parseUnits(amount.toString(), decimals))
+    };
+    const queryGasParams = {
+      chainIndex: Number(chainId || BaseConfig.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 } = BaseConfig;
+      return {
+        success: true,
+        gasFee: gasFee.toString()
+      };
+    }
+    const { baseFee = 1, gasLimit = 1 } = gasInfo;
+    const calcFee = (feeLevel) => {
+      const gasFee = new 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]
+    };
+  }
+};
+function getRPCClient(network2) {
+  const { chainId, name, rpcUrls, nativeCurrencyDecimals, nativeCurrencyName, nativeCurrencySymbol } = network2;
   const myCustomChain = {
     id: Number(chainId) || chainId,
     name,
@@ -3952,20 +4698,20 @@ 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 (isHex(chainId)) {
     const chainIdHex2 = chainId;
-    chainId = fromHex(chainId, "number").toString();
+    chainId = fromHex$1(chainId, "number").toString();
     return {
       chainId,
       chainIdHex: chainIdHex2,
       chainUid: `${chainType}:${chainId}`
     };
   }
-  const chainIdHex = toHex(Number(chainId));
+  const chainIdHex = toHex$1(Number(chainId));
   return {
     chainId,
     chainIdHex,
@@ -4045,7 +4791,7 @@ var EvmService = class _EvmService extends BaseService {
   }
   async personal_sign([message, address]) {
     const accounts = await this.accountInfo.getCurrent();
-    if (accounts[0].address !== address) {
+    if (!isAddressEqual(accounts[0].address, address)) {
       throw new Error("address is not the current account");
     }
     const signature = await this.accountInfo.signMessage(message);
@@ -4053,7 +4799,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 (!isAddressEqual(accounts[0].address, address)) {
       throw new Error("address is not the current account");
     }
     const signature = await this.accountInfo.signTypedData(typedData);
@@ -4061,7 +4807,7 @@ var EvmService = class _EvmService extends BaseService {
   }
   async eth_getBalance([address, type]) {
     const accounts = await this.accountInfo.getCurrent();
-    if (accounts[0].address !== address) {
+    if (!isAddressEqual(accounts[0].address, address)) {
       throw new Error("address is not the current account");
     }
     if (type !== "latest") {
@@ -4079,7 +4825,7 @@ var EvmService = class _EvmService extends BaseService {
   }
   async _queryGasInfo(txData) {
     const { tokenAddress, chainId, amount = 0, decimals = 9 } = txData;
-    const value = tokenAddress ? "0x1" : toHex(parseUnits(amount.toString(), decimals));
+    const value = tokenAddress ? "0x1" : toHex$1(parseUnits(amount.toString(), decimals));
     let callData = "0x";
     if (tokenAddress) {
       callData = createErc20TxData(txData, { decimals, address: tokenAddress })?.data;
@@ -4105,8 +4851,8 @@ var EvmService = class _EvmService extends BaseService {
     });
     if (!success) {
       console.error("queryGasInfo evm", txData, queryGasParams, message, gasInfo);
-      const BaseConfig2 = SupportedChainTypes[ChainTypes.EVM];
-      const { gasFee } = BaseConfig2;
+      const BaseConfig3 = SupportedChainTypes[ChainTypes.EVM];
+      const { gasFee } = BaseConfig3;
       return {
         success: true,
         gasFee: gasFee.toString()
@@ -4138,51 +4884,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 } = 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(baseFee);
-    const calcFee = (feeLevel) => {
-      const fee = baseFeeBN.plus(gasInfo[feeLevel] || 0);
-      const gasFee = fee.times(gasLimit);
-      return toHex(BigInt(gasFee.toNumber()), nativeCurrencyDecimals);
-    };
-    return calcFee("priorityFeeMedium");
-  }
   async createPublicClient({ chainId, rpcUrl }) {
     if (rpcUrl) {
       return createPublicClient({
@@ -4204,6 +4905,26 @@ var EvmService = class _EvmService extends BaseService {
       transport: 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: hexToBigInt(value) });
+      return gas;
+    } catch (error) {
+      console.warn("Failed to estimate gas:", error);
+      const BaseConfig3 = SupportedChainTypes[ChainTypes.EVM];
+      const { gasFee } = BaseConfig3;
+      return numberToHex(parseUnits(gasFee.toString(), 18));
+    }
+  }
   // Get nonce for current account
   async eth_getTransactionCount([address, type]) {
     const accounts = await this.accountInfo.getCurrent();
@@ -4232,30 +4953,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 && !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] || !isHex(txData?.[key])) {
-        throw new Error(`${key}: no data or wrong type`);
+      if (txData?.[key] && isHex(txData?.[key])) {
+        preparedTx[key] = preparedTxPropsType[key] === "number" ? fromHex$1(txData[key], "number") : txData[key];
       }
-      preparedTx[key] = preparedTxPropsType[key] === "number" ? fromHex(txData[key], "number") : txData[key];
+    }
+    if (txData?.type !== "legacy") {
+      delete preparedTx.gasPrice;
     }
     try {
       const serializedTransaction = await this.accountInfo.signTransaction(
@@ -4301,7 +5027,7 @@ var EvmService = class _EvmService extends BaseService {
     }
   }
 };
-var BaseConfig = SupportedChainTypes[ChainTypes.SOL];
+var BaseConfig2 = SupportedChainTypes[ChainTypes.SOL];
 var TOKEN_METADATA_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
 var MSG_PREFIX = "\xFFsolana offchain";
 
@@ -4312,7 +5038,7 @@ var txToHex = (tx) => {
   if (tx instanceof VersionedTransaction) {
     return Buffer.from(tx.serialize()).toString("hex");
   }
-  if (tx instanceof Transaction) {
+  if (tx instanceof Transaction$1) {
     return Buffer.from(
       tx.serialize({
         requireAllSignatures: false,
@@ -4326,7 +5052,7 @@ async function createLegacyTx({ from = "", to = "", amount = 0 }, connection) {
   const fromPubkey = new PublicKey(from);
   const toPubkey = new PublicKey(to);
   const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
-  const transaction = new Transaction().add(
+  const transaction = new Transaction$1().add(
     SystemProgram.transfer({
       fromPubkey,
       //payer
@@ -4356,7 +5082,7 @@ async function createTokenLegacyTransaction2({
     const fromTokenPubKey = await getAssociatedTokenAddress(tokenPublicKey, fromPubkey);
     const toTokenPubKey = await getAssociatedTokenAddress(tokenPublicKey, toPubkey);
     const { blockhash } = await connection.getLatestBlockhash("confirmed");
-    const transaction = new Transaction();
+    const transaction = new Transaction$1();
     transaction.feePayer = fromPubkey;
     transaction.recentBlockhash = blockhash;
     try {
@@ -4376,13 +5102,6 @@ async function createTokenLegacyTransaction2({
     throw error;
   }
 }
-
-// src/dogecoin/base.ts
-function toBase58(data) {
-  throw new Error("toBase58 requires bs58 package. Install it: pnpm add bs58");
-}
-
-// src/solana/service.ts
 var SolanaService = class _SolanaService extends BaseService {
   static instance;
   chainType;
@@ -4414,11 +5133,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 {
@@ -4428,7 +5147,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,
@@ -4445,7 +5164,7 @@ var SolanaService = class _SolanaService extends BaseService {
   }
   async _queryGasInfo(txData) {
     const { tokenAddress, chainId, amount = 0, decimals = 9 } = txData;
-    const value = tokenAddress ? "0x1" : toHex(parseUnits(amount.toString(), decimals));
+    const value = tokenAddress ? "0x1" : toHex$1(parseUnits(amount.toString(), decimals));
     let callData = "0x";
     if (tokenAddress) {
       const transaction = await createTokenLegacyTransaction2(txData, this.connection);
@@ -4475,7 +5194,7 @@ var SolanaService = class _SolanaService extends BaseService {
     });
     if (!success) {
       console.error("queryGasInfo solana", txData, message, gasInfo);
-      const { gasFee } = BaseConfig;
+      const { gasFee } = BaseConfig2;
       return {
         success: true,
         gasFee: gasFee.toString()
@@ -4638,8 +5357,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) {
@@ -4706,8 +5425,8 @@ var TomoWallet = class _TomoWallet extends BaseService {
 // src/index.ts
 var ChainTypeServices = {
   [ChainTypes.EVM]: EvmService,
-  [ChainTypes.SOL]: SolanaService
-  // [ChainTypes.DOGE]: DogecoinService,
+  [ChainTypes.SOL]: SolanaService,
+  [ChainTypes.DOGE]: DogecoinService
 };
 
-export { AccountType, ChainTypeServices, EvmService, SolanaService, TomoWallet, TxTypes };
+export { AccountType, ChainTypeServices, rpc_exports as DogecoinAPI, DogecoinAddress, DogecoinService, DogecoinUtils, EvmService, SolanaService, TomoWallet, TransactionParser, TxTypes, addUsedUtxos, createPsbt, decodePsbt, getUsedUtxos, toBitcoin, toSatoshi };