@tomo-inc/chains-service 0.0.7 → 0.0.9

package/dist/index.cjs

@@ -1,18 +1,19 @@
 'use strict';
 
 var walletUtils = require('@tomo-inc/wallet-utils');
-var Bignumber = require('bignumber.js');
-var viem = require('viem');
 var axios = require('axios');
 var CryptoJS = require('crypto-js');
+var Bignumber = require('bignumber.js');
+var bitcoinjsLib = require('bitcoinjs-lib');
+var viem = require('viem');
 var splToken = require('@solana/spl-token');
 var web3_js = require('@solana/web3.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var Bignumber__default = /*#__PURE__*/_interopDefault(Bignumber);
 var axios__default = /*#__PURE__*/_interopDefault(axios);
 var CryptoJS__default = /*#__PURE__*/_interopDefault(CryptoJS);
+var Bignumber__default = /*#__PURE__*/_interopDefault(Bignumber);
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -23,6 +24,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))
@@ -2804,18 +2809,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 +2843,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 +2852,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 +2983,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 +3024,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 +3120,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 +3275,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",
@@ -3894,7 +3930,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 +3940,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 = walletUtils.SupportedChainTypes[walletUtils.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.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);
+}
+function getUsedUtxos() {
+  return walletUtils.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 bitcoinjsLib.Psbt.fromHex(psbtHex, {
+        network
+      });
+    }
+    return bitcoinjsLib.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__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 || {};
+}
+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) {
+    try {
+      const decoded = bitcoinjsLib.address.fromBase58Check(address);
+      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 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: 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 = 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).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 = bitcoinjsLib.address.fromOutputScript(output.script, network);
+          psbt.addOutput({
+            address,
+            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: viem.toHex(viem.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.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,
@@ -3960,8 +4706,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 +4799,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 +4807,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 +4815,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 +4859,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 +4892,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 +4913,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 +4961,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(
@@ -4309,7 +5035,7 @@ var EvmService = class _EvmService extends BaseService {
     }
   }
 };
-var BaseConfig = walletUtils.SupportedChainTypes[walletUtils.ChainTypes.SOL];
+var BaseConfig2 = walletUtils.SupportedChainTypes[walletUtils.ChainTypes.SOL];
 var TOKEN_METADATA_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
 var MSG_PREFIX = "\xFFsolana offchain";
 
@@ -4384,13 +5110,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;
@@ -4422,11 +5141,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 +5155,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,
@@ -4483,7 +5202,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()
@@ -4646,8 +5365,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,13 +5433,24 @@ 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.DogecoinAPI = rpc_exports;
+exports.DogecoinAddress = DogecoinAddress;
+exports.DogecoinService = DogecoinService;
+exports.DogecoinUtils = DogecoinUtils;
 exports.EvmService = EvmService;
 exports.SolanaService = SolanaService;
 exports.TomoWallet = TomoWallet;
+exports.TransactionParser = TransactionParser;
 exports.TxTypes = TxTypes;
+exports.addUsedUtxos = addUsedUtxos;
+exports.createPsbt = createPsbt;
+exports.decodePsbt = decodePsbt;
+exports.getUsedUtxos = getUsedUtxos;
+exports.toBitcoin = toBitcoin;
+exports.toSatoshi = toSatoshi;