@tomo-inc/chains-service 0.0.8 → 0.0.10

package/dist/index.js

@@ -1,11 +1,11 @@
-import { ChainTypes, SupportedChainTypes, cache, TomoApiDomains, getExplorerUrl } from '@tomo-inc/wallet-utils';
-import Bignumber, { BigNumber } from 'bignumber.js';
-import { toHex, parseUnits, isAddressEqual, createPublicClient, http, hexToBigInt, numberToHex, isHex, fromHex, parseTransaction, formatUnits, encodeFunctionData, erc20Abi } from 'viem';
+import { ChainTypes, SupportedChainTypes, TomoApiDomains, cache, getExplorerUrl } from '@tomo-inc/wallet-utils';
 import axios from 'axios';
 import CryptoJS from 'crypto-js';
+import Bignumber, { BigNumber } from 'bignumber.js';
+import { Psbt, Transaction, address } from 'bitcoinjs-lib';
+import { toHex as toHex$1, parseUnits, isAddressEqual, createPublicClient, http, hexToBigInt, numberToHex, isHex, fromHex as fromHex$1, parseTransaction, formatUnits, encodeFunctionData, erc20Abi } from 'viem';
 import { getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { PublicKey, Connection, VersionedTransaction, sendAndConfirmRawTransaction, Transaction as Transaction$1, SystemProgram, LAMPORTS_PER_SOL } from '@solana/web3.js';
-import { Psbt, Transaction, address } from 'bitcoinjs-lib';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -16,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))
@@ -2897,24 +2901,6 @@ var Transactions = class {
     return res?.data || {};
   }
 };
-function getConfig(tomoStage) {
-  const domain = TomoApiDomains[tomoStage];
-  if (!domain) {
-    throw new Error("Invalid tomo stage");
-  }
-  return {
-    rpcBaseUrl: `${domain}`,
-    walletBaseUrl: `${domain}/wallet`,
-    txBaseUrl: `${domain}/quote`,
-    tokenBaseUrl: `${domain}/token`,
-    userBaseUrl: `${domain}/user/api`
-  };
-}
-var CONFIG = {
-  prod: getConfig("prod"),
-  pre: getConfig("pre"),
-  dev: getConfig("dev")
-};
 function generateSignature(config) {
   const timestamp = Math.floor(Date.now() / 1e3).toString();
   const method = config.method.toUpperCase();
@@ -3276,6 +3262,20 @@ var loadNetworks = (WALLET_DOMAIN) => {
       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,
@@ -3889,6 +3889,24 @@ function tomoPublicApiService(publicApiBase, tomoAppInfo) {
     walletAPIs: WalletAPIs.getInstance(publicApiBase, tomoAppInfo)
   };
 }
+function getConfig(tomoStage) {
+  const domain = TomoApiDomains[tomoStage];
+  if (!domain) {
+    throw new Error("Invalid tomo stage");
+  }
+  return {
+    rpcBaseUrl: `${domain}`,
+    walletBaseUrl: `${domain}/wallet`,
+    txBaseUrl: `${domain}/quote`,
+    tokenBaseUrl: `${domain}/token`,
+    userBaseUrl: `${domain}/user/api`
+  };
+}
+var CONFIG = {
+  prod: getConfig("prod"),
+  pre: getConfig("pre"),
+  dev: getConfig("dev")
+};
 
 // src/base/service.ts
 var BaseService = class {
@@ -3914,571 +3932,934 @@ var BaseService = class {
     this.approveParams = params;
   }
 };
-function getRPCClient(network2) {
-  const { chainId, name, rpcUrls, nativeCurrencyDecimals, nativeCurrencyName, nativeCurrencySymbol } = network2;
-  const myCustomChain = {
-    id: Number(chainId) || chainId,
-    name,
-    nativeCurrency: {
-      name: nativeCurrencyName,
-      symbol: nativeCurrencySymbol,
-      decimals: nativeCurrencyDecimals
-    },
-    rpcUrls: {
-      default: {
-        http: rpcUrls,
-        webSocket: []
-      },
-      public: {
-        http: rpcUrls,
-        webSocket: []
-      }
-    },
-    blockExplorers: {
-      default: {
-        name: "Explorer",
-        url: rpcUrls[0]
-      }
-    }
-  };
-  const rpcClient = createPublicClient({
-    chain: myCustomChain,
-    pollingInterval: 1e4,
-    cacheTime: 1e4,
-    transport: http()
-  });
-  return { rpcClient };
-}
-
-// src/types/account.ts
-var AccountType = /* @__PURE__ */ ((AccountType2) => {
-  AccountType2["EOA"] = "EOA";
-  AccountType2["SOCIAL"] = "SOCIAL";
-  return AccountType2;
-})(AccountType || {});
-
-// src/types/wallet.ts
-var TxTypes = /* @__PURE__ */ ((TxTypes2) => {
-  TxTypes2[TxTypes2["swap"] = 1] = "swap";
-  TxTypes2[TxTypes2["bridge"] = 2] = "bridge";
-  TxTypes2[TxTypes2["receive"] = 31] = "receive";
-  TxTypes2[TxTypes2["send"] = 32] = "send";
-  TxTypes2[TxTypes2["approve"] = 4] = "approve";
-  TxTypes2[TxTypes2["contractInteraction"] = 5] = "contractInteraction";
-  TxTypes2[TxTypes2["redPocket"] = 6] = "redPocket";
-  return TxTypes2;
-})(TxTypes || {});
 
-// src/evm/utils.ts
-var isEvmChain = (network2) => {
-  return network2 && network2?.platformType === "EVM";
-};
-var getAllTypeChainIds = ({ chainId, chainType }) => {
-  if (isHex(chainId)) {
-    const chainIdHex2 = chainId;
-    chainId = fromHex(chainId, "number").toString();
-    return {
-      chainId,
-      chainIdHex: chainIdHex2,
-      chainUid: `${chainType}:${chainId}`
-    };
+// 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);
   }
-  const chainIdHex = toHex(Number(chainId));
-  return {
-    chainId,
-    chainIdHex,
-    chainUid: `${chainType}:${chainId}`
-  };
-};
-function createErc20TxData(params, token) {
-  const { decimals, address: tokenAddress } = token;
-  const value = parseUnits(params?.amount.toString(), decimals);
-  const callData = encodeFunctionData({
-    abi: erc20Abi,
-    functionName: "transfer",
-    args: [params.to, value]
-  });
-  return {
-    ...params,
-    ...{ amount: 0, data: callData, to: tokenAddress }
-  };
+  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/evm/service.ts
-var EvmService = class _EvmService extends BaseService {
-  static instance;
-  chainType;
-  constructor(chainType, accountInfo, tomoAppInfo) {
-    super(tomoAppInfo, accountInfo);
-    this.chainType = chainType;
+// 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}`);
   }
-  static getInstance(chainType, accountInfo, tomoAppInfo) {
-    if (!_EvmService.instance) {
-      _EvmService.instance = new _EvmService(chainType, accountInfo, tomoAppInfo);
+}
+function toBitcoin(satoshis) {
+  try {
+    const amount = new BigNumber(satoshis);
+    if (amount.isNaN() || amount.isNegative()) {
+      throw new Error("Invalid Koinu amount");
     }
-    return _EvmService.instance;
+    return amount.dividedBy(KOINU_PER_DOGE).toNumber();
+  } catch (error) {
+    throw new Error(`toBitcoin failed: ${error.message}`);
   }
-  async eth_requestAccounts() {
-    const res = await this.eth_accounts();
-    return res;
+}
+function addUsedUtxos(newUsedUtxos) {
+  const usedUtxos = cache.get("UsedUtxos") || {};
+  for (const txid in newUsedUtxos) {
+    usedUtxos[txid] = 1;
   }
-  async eth_accounts() {
-    const accounts = await this.accountInfo.getCurrent();
-    return accounts.map((account) => account.address);
+  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");
   }
-  async eth_chainId() {
-    const chainType = this.chainType;
-    const currentNetwork = await this.getCurrentChain();
-    const { chainIdHex } = getAllTypeChainIds({
-      chainId: currentNetwork?.chainId,
-      chainType
-    });
-    return chainIdHex;
+  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);
   }
-  async getCurrentChain() {
-    this.networks.setChainType(this.chainType);
-    const currentNetwork = await this.networks.getCurrentNetwork();
-    return currentNetwork;
+  if (accumulatedAmount < totalNeeded) {
+    throw new Error("not enough funds to cover amount and fee");
   }
-  async wallet_switchEthereumChain(networks) {
-    const { chainId } = networks[0];
-    const isSupported = await this.isChainSupported(chainId);
-    if (!isSupported) {
-      throw new Error(`Chain ${chainId} is not supported`);
-    }
-    return await this.networks.setCurrentNetwork(chainId);
-  }
-  //evm chains
-  async isChainSupported(chainId) {
-    const chainType = this.chainType;
-    const res = getAllTypeChainIds({ chainId, chainType });
-    if (!res.chainId) {
-      return false;
+  const utxoDetailPromises = selectedUtxos.map(async (utxo) => {
+    try {
+      const utxoDetail = await getTxDetail(utxo.txid);
+      return { utxo, utxoDetail };
+    } catch (error) {
+      return { utxo, utxoDetail: null };
     }
-    const chainInfo = await this.networks.getNetworkByChainId(res.chainId);
-    if (!chainInfo) {
-      return false;
+  });
+  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);
     }
-    return isEvmChain(chainInfo);
   }
-  async personal_sign([message, address]) {
-    const accounts = await this.accountInfo.getCurrent();
-    if (!isAddressEqual(accounts[0].address, address)) {
-      throw new Error("address is not the current account");
-    }
-    const signature = await this.accountInfo.signMessage(message);
-    return signature;
+  if (addedAmount < totalNeeded) {
+    throw new Error("not enough funds to cover amount and fee");
   }
-  async eth_signTypedData_v4([address, typedData]) {
-    const accounts = await this.accountInfo.getCurrent();
-    if (!isAddressEqual(accounts[0].address, address)) {
-      throw new Error("address is not the current account");
+  const outputs = [
+    {
+      address: to,
+      amount: sendAmount
     }
-    const signature = await this.accountInfo.signTypedData(typedData);
-    return signature;
+  ];
+  const changeAmount = addedAmount - sendAmount - sendCost;
+  if (changeAmount > 0) {
+    outputs.push({
+      address: from,
+      amount: changeAmount
+    });
   }
-  async eth_getBalance([address, type]) {
-    const accounts = await this.accountInfo.getCurrent();
-    if (!isAddressEqual(accounts[0].address, address)) {
-      throw new Error("address is not the current account");
-    }
-    if (type !== "latest") {
-      throw new Error("type is not supported");
-    }
-    const chainInfo = await this.getCurrentChain();
-    const { rpcClient } = getRPCClient(chainInfo);
-    try {
-      const balance = await rpcClient.getBalance({ address });
-      return balance?.toString() || "0";
-    } catch (error) {
-      console.error(error);
-      return "0";
+  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;
   }
-  async _queryGasInfo(txData) {
-    const { tokenAddress, chainId, amount = 0, decimals = 9 } = txData;
-    const value = tokenAddress ? "0x1" : toHex(parseUnits(amount.toString(), decimals));
-    let callData = "0x";
-    if (tokenAddress) {
-      callData = createErc20TxData(txData, { decimals, address: tokenAddress })?.data;
+}
+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));
     }
-    const gasLimitParam = {
-      from: txData.from,
-      to: txData.to,
-      value
-    };
-    const queryGasParams = {
-      chainIndex: Number(chainId),
-      callData,
-      gasLimitParam,
-      addressList: [txData.from]
+    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()
     };
-    const {
-      data: gasInfo,
-      success,
-      message
-    } = await this.transactions.queryGasInfo({
-      chainType: this.chainType,
-      params: queryGasParams
-    });
-    if (!success) {
-      console.error("queryGasInfo evm", txData, queryGasParams, message, gasInfo);
-      const BaseConfig3 = SupportedChainTypes[ChainTypes.EVM];
-      const { gasFee } = BaseConfig3;
-      return {
-        success: true,
-        gasFee: gasFee.toString()
-      };
-    }
-    const nativeChainId = SupportedChainTypes[this.chainType].chainId;
-    const { nativeCurrency } = await this.networks.getNetworkByChainId(nativeChainId);
-    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 formatUnits(BigInt(gasFee.toNumber()), nativeCurrency?.decimals || 9);
+  }
+  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 {
-      success,
-      fees: {
-        low: calcFee("priorityFeeLow"),
-        medium: calcFee("priorityFeeMedium"),
-        high: calcFee("priorityFeeHigh")
-      },
-      gasFee: calcFee("priorityFeeMedium"),
-      baseFee,
-      gasLimit,
-      priorityFee: {
-        low: gasInfo.priorityFeeLow,
-        medium: gasInfo.priorityFeeMedium,
-        high: gasInfo.priorityFeeHigh
-      }
+      address: "",
+      balance: 0
     };
   }
-  async createPublicClient({ chainId, rpcUrl }) {
-    if (rpcUrl) {
-      return createPublicClient({
-        transport: http(rpcUrl)
-      });
-    }
-    if (chainId) {
-      this.networks.setChainType(this.chainType);
-      const chainInfo = await this.networks.getNetworkByChainId(chainId);
-      rpcUrl = chainInfo.rpcUrls[0];
-    } else {
-      const chainInfo = await this.getCurrentChain();
-      rpcUrl = chainInfo.rpcUrls[0];
-    }
-    if (!rpcUrl) {
-      throw new Error("rpcUrl is not set");
-    }
-    return createPublicClient({
-      transport: http(rpcUrl)
-    });
+  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 {};
   }
-  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));
-    }
+  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);
   }
-  // Get nonce for current account
-  async eth_getTransactionCount([address, type]) {
-    const accounts = await this.accountInfo.getCurrent();
-    if (accounts[0].address !== address) {
-      throw new Error("address is not the current account");
-    }
-    if (type !== "latest" && type !== "pending") {
-      throw new Error("type is not supported");
-    }
-    try {
-      const rpcClient = await this.createPublicClient({});
-      const nonce = await rpcClient.getTransactionCount({ address });
-      return nonce;
-    } catch (error) {
-      console.error("Failed to get nonce:", error);
-      throw new Error(`Failed to get nonce: ${error}`);
-    }
+  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;
   }
-  //https://docs.metamask.io/snaps/reference/keyring-api/chain-methods/#eth_signtransaction
-  async eth_signTransaction(txParams) {
-    const preparedTxPropsType = {
-      chainId: "number",
-      to: "string",
-      value: "bigint",
-      data: "string",
-      nonce: "number",
-      maxPriorityFeePerGas: "bigint",
-      maxFeePerGas: "bigint",
-      gasPrice: "bigint",
-      gas: "bigint"
-    };
-    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");
+  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;
     }
-    const accounts = await this.accountInfo.getCurrent();
-    const address = accounts[0].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`);
+    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;
     }
-    delete txData?.from;
-    delete txData?.gasLimit;
-    const preparedTx = {
-      gas: txData?.gas
-    };
-    for (const key in preparedTxPropsType) {
-      if (txData?.[key] && isHex(txData?.[key])) {
-        preparedTx[key] = preparedTxPropsType[key] === "number" ? fromHex(txData[key], "number") : txData[key];
+  }
+};
+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);
     }
-    if (txData?.type !== "legacy") {
-      delete preparedTx.gasPrice;
+    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 serializedTransaction = await this.accountInfo.signTransaction(
-        JSON.stringify({
-          data: preparedTx,
-          types: preparedTxPropsType
-        })
-      );
-      if (serializedTransaction === "") {
-        throw new Error(`eth_signTransaction error data: ${JSON.stringify(txParams)}`);
+      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);
       }
-      const data = parseTransaction(serializedTransaction);
-      return data;
-    } catch (err) {
-      throw new Error("eth_signTransaction error" + err);
+      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)}`
+      );
     }
   }
-  async eth_sendRawTransaction([serializedTransaction], rpcUrl) {
-    try {
-      const rpcClient = await this.createPublicClient({ rpcUrl });
-      const hash = await rpcClient.sendRawTransaction({
-        serializedTransaction
-      });
-      return hash;
-    } catch (error) {
-      console.error("Failed to send transaction via RPC:", error, rpcUrl);
-      throw 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 getTransaction(hash) {
-    if (!hash || !isHex(hash)) {
-      throw new Error("txId is not valid");
+  async requestAccounts() {
+    const addresses = await this.accountInfo.getCurrent();
+    return addresses.map((account) => account.address);
+  }
+  async getAccounts() {
+    return await this.requestAccounts();
+  }
+  async getConnectionStatus() {
+    const addresses = await this.accountInfo.getCurrent();
+    const { address } = addresses?.[0] || {};
+    if (!address) {
+      throw new Error("address is not set");
     }
-    try {
-      const rpcClient = await this.createPublicClient({});
-      const tx = await rpcClient.getTransaction({
-        hash
-      });
-      return tx;
-    } catch (error) {
-      console.error("Failed to send transaction via RPC:", error, hash);
-      throw error;
+    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 {
+      confirmed: balance,
+      unconfirmed: 0,
+      total: balance
+    };
   }
-};
-var BaseConfig = SupportedChainTypes[ChainTypes.SOL];
-var TOKEN_METADATA_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
-var MSG_PREFIX = "\xFFsolana offchain";
-
-// src/solana/utils.ts
-__toESM(require_bn());
-new PublicKey(TOKEN_METADATA_PROGRAM_ID);
-var txToHex = (tx) => {
-  if (tx instanceof VersionedTransaction) {
-    return Buffer.from(tx.serialize()).toString("hex");
+  async signMessage({ message, type }) {
+    if (type) {
+      throw new Error("bip322simple not support.");
+    }
+    const signature = await this.accountInfo.signMessage(message);
+    return signature;
   }
-  if (tx instanceof Transaction$1) {
-    return Buffer.from(
-      tx.serialize({
-        requireAllSignatures: false,
-        verifySignatures: false
-      })
-    ).toString("hex");
+  async requestSignedMessage({
+    message,
+    type
+  }) {
+    const signedMessage = await this.signMessage({
+      message,
+      type
+    });
+    return {
+      signedMessage
+    };
   }
-  return tx;
-};
-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$1().add(
-    SystemProgram.transfer({
-      fromPubkey,
-      //payer
-      toPubkey,
-      //toAccount
-      lamports: amount * LAMPORTS_PER_SOL
-    })
-  );
-  transaction.feePayer = fromPubkey;
-  transaction.recentBlockhash = blockhash;
-  transaction.lastValidBlockHeight = lastValidBlockHeight;
-  return transaction;
-}
-async function createTokenLegacyTransaction2({
-  from = "",
-  to = "",
-  amount = 0,
-  tokenAddress = "",
-  priorityFee = 0,
-  // microLamports (1 SOL = 1e6 microLamports)
-  decimals = 6
-}, connection) {
-  try {
-    const fromPubkey = new PublicKey(from);
-    const toPubkey = new PublicKey(to);
-    const tokenPublicKey = new PublicKey(tokenAddress);
-    const fromTokenPubKey = await getAssociatedTokenAddress(tokenPublicKey, fromPubkey);
-    const toTokenPubKey = await getAssociatedTokenAddress(tokenPublicKey, toPubkey);
-    const { blockhash } = await connection.getLatestBlockhash("confirmed");
-    const transaction = new Transaction$1();
-    transaction.feePayer = fromPubkey;
-    transaction.recentBlockhash = blockhash;
+  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 signPsbt({ psbtHex, options }) {
+    const psbtBase64 = toBase64(fromHex(psbtHex));
+    const signedPsbt = await this.accountInfo.signTransaction(JSON.stringify({ psbtBase64 }));
+    if (!signedPsbt) {
+      throw new Error("error psbtHex:" + psbtHex);
+    }
+    const signedRawTx = DogecoinUtils.extractPsbtTransaction(signedPsbt, 1e5);
+    return signedRawTx;
+  }
+  async signPsbts({ psbtHexs, options }) {
+    throw new Error("not implemented");
+  }
+  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 instruction = createAssociatedTokenAccountInstruction(fromPubkey, toTokenPubKey, toPubkey, tokenPublicKey);
-      transaction.add(instruction);
-    } catch (error) {
-      console.error(error);
-      throw error;
+      const { txid } = await sendDogeTx(signedTx);
+      addUsedUtxos(usingUtxos);
+      return { txId: txid };
+    } catch (err) {
+      throw new Error("Error: send transaction err." + JSON.stringify(err));
     }
-    const tokenAmount = new Bignumber(amount).multipliedBy(new Bignumber(10).pow(decimals)).toNumber();
-    transaction.add(
-      createTransferInstruction(fromTokenPubKey, toTokenPubKey, fromPubkey, tokenAmount, [], TOKEN_PROGRAM_ID)
-    );
-    return transaction;
-  } catch (error) {
-    console.error("Error creating transaction:", error);
-    throw error;
   }
-}
-
-// 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);
+  async send({
+    toAddress,
+    amount,
+    fee = 0,
+    options
+  }) {
+    if (fee <= 0) {
+      throw new Error("fee is required");
+    }
+    const addresses = await this.accountInfo.getCurrent();
+    const { address } = addresses?.[0] || {};
+    const txData = {
+      to: toAddress,
+      amount: toBitcoin(amount),
+      fee: toBitcoin(fee || 0),
+      from: address
+    };
+    const res = await this.requestTransaction(txData);
+    return res?.txId || "";
+  }
+  async sendDogecoin({
+    toAddress,
+    amount,
+    options,
+    fee
+  }) {
+    return await this.send({ toAddress, amount, options, fee });
   }
-  return bytes;
-}
-function toHex3(data) {
-  if (typeof data === "string") {
-    return data.startsWith("0x") ? data.slice(2) : data;
+  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]
+    };
   }
-  const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
-  return buffer.toString("hex");
+};
+function getRPCClient(network2) {
+  const { chainId, name, rpcUrls, nativeCurrencyDecimals, nativeCurrencyName, nativeCurrencySymbol } = network2;
+  const myCustomChain = {
+    id: Number(chainId) || chainId,
+    name,
+    nativeCurrency: {
+      name: nativeCurrencyName,
+      symbol: nativeCurrencySymbol,
+      decimals: nativeCurrencyDecimals
+    },
+    rpcUrls: {
+      default: {
+        http: rpcUrls,
+        webSocket: []
+      },
+      public: {
+        http: rpcUrls,
+        webSocket: []
+      }
+    },
+    blockExplorers: {
+      default: {
+        name: "Explorer",
+        url: rpcUrls[0]
+      }
+    }
+  };
+  const rpcClient = createPublicClient({
+    chain: myCustomChain,
+    pollingInterval: 1e4,
+    cacheTime: 1e4,
+    transport: http()
+  });
+  return { rpcClient };
 }
-function toBase64(data) {
-  if (typeof data === "string") {
-    const buffer2 = Buffer.from(data, "hex");
-    return buffer2.toString("base64");
+
+// src/types/account.ts
+var AccountType = /* @__PURE__ */ ((AccountType2) => {
+  AccountType2["EOA"] = "EOA";
+  AccountType2["SOCIAL"] = "SOCIAL";
+  return AccountType2;
+})(AccountType || {});
+
+// src/types/wallet.ts
+var TxTypes = /* @__PURE__ */ ((TxTypes2) => {
+  TxTypes2[TxTypes2["swap"] = 1] = "swap";
+  TxTypes2[TxTypes2["bridge"] = 2] = "bridge";
+  TxTypes2[TxTypes2["receive"] = 31] = "receive";
+  TxTypes2[TxTypes2["send"] = 32] = "send";
+  TxTypes2[TxTypes2["approve"] = 4] = "approve";
+  TxTypes2[TxTypes2["contractInteraction"] = 5] = "contractInteraction";
+  TxTypes2[TxTypes2["redPocket"] = 6] = "redPocket";
+  return TxTypes2;
+})(TxTypes || {});
+
+// src/evm/utils.ts
+var isEvmChain = (network2) => {
+  return network2 && network2?.platformType === "EVM";
+};
+var getAllTypeChainIds = ({ chainId, chainType }) => {
+  if (isHex(chainId)) {
+    const chainIdHex2 = chainId;
+    chainId = fromHex$1(chainId, "number").toString();
+    return {
+      chainId,
+      chainIdHex: chainIdHex2,
+      chainUid: `${chainType}:${chainId}`
+    };
   }
-  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");
+  const chainIdHex = toHex$1(Number(chainId));
+  return {
+    chainId,
+    chainIdHex,
+    chainUid: `${chainType}:${chainId}`
+  };
+};
+function createErc20TxData(params, token) {
+  const { decimals, address: tokenAddress } = token;
+  const value = parseUnits(params?.amount.toString(), decimals);
+  const callData = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "transfer",
+    args: [params.to, value]
+  });
+  return {
+    ...params,
+    ...{ amount: 0, data: callData, to: tokenAddress }
+  };
 }
 
-// src/solana/service.ts
-var SolanaService = class _SolanaService extends BaseService {
+// src/evm/service.ts
+var EvmService = class _EvmService extends BaseService {
   static instance;
   chainType;
-  rpcUrl;
-  connection;
   constructor(chainType, accountInfo, tomoAppInfo) {
     super(tomoAppInfo, accountInfo);
     this.chainType = chainType;
-    const config = {
-      commitment: "confirmed",
-      disableRetryOnRateLimit: false,
-      confirmTransactionInitialTimeout: 12e4,
-      fetch: (url, options) => {
-        return fetch(url, { ...options });
-      }
-    };
-    const domain = TomoApiDomains[tomoAppInfo.tomoStage];
-    const rpcUrl = `${domain}/rpc/v1/solana`;
-    this.rpcUrl = rpcUrl;
-    this.connection = new Connection(rpcUrl, config);
   }
   static getInstance(chainType, accountInfo, tomoAppInfo) {
-    if (!_SolanaService.instance) {
-      _SolanaService.instance = new _SolanaService(chainType, accountInfo, tomoAppInfo);
+    if (!_EvmService.instance) {
+      _EvmService.instance = new _EvmService(chainType, accountInfo, tomoAppInfo);
     }
-    return _SolanaService.instance;
+    return _EvmService.instance;
   }
-  async getCurrentWalletAccount() {
-    return await this.accountInfo.getCurrent();
+  async eth_requestAccounts() {
+    const res = await this.eth_accounts();
+    return res;
   }
-  async getAccount() {
-    const { address: currentAddress, publicKey } = await this.accountInfo.getCurrent();
-    return { publicKey: publicKey || currentAddress, address: currentAddress };
+  async eth_accounts() {
+    const accounts = await this.accountInfo.getCurrent();
+    return accounts.map((account) => account.address);
   }
-  async signMessage(params) {
-    const { address: currentAddress, publicKey } = await this.accountInfo.getCurrent();
-    const { message } = params;
+  async eth_chainId() {
+    const chainType = this.chainType;
+    const currentNetwork = await this.getCurrentChain();
+    const { chainIdHex } = getAllTypeChainIds({
+      chainId: currentNetwork?.chainId,
+      chainType
+    });
+    return chainIdHex;
+  }
+  async getCurrentChain() {
+    this.networks.setChainType(this.chainType);
+    const currentNetwork = await this.networks.getCurrentNetwork();
+    return currentNetwork;
+  }
+  async wallet_switchEthereumChain(networks) {
+    const { chainId } = networks[0];
+    const isSupported = await this.isChainSupported(chainId);
+    if (!isSupported) {
+      throw new Error(`Chain ${chainId} is not supported`);
+    }
+    return await this.networks.setCurrentNetwork(chainId);
+  }
+  //evm chains
+  async isChainSupported(chainId) {
+    const chainType = this.chainType;
+    const res = getAllTypeChainIds({ chainId, chainType });
+    if (!res.chainId) {
+      return false;
+    }
+    const chainInfo = await this.networks.getNetworkByChainId(res.chainId);
+    if (!chainInfo) {
+      return false;
+    }
+    return isEvmChain(chainInfo);
+  }
+  async personal_sign([message, address]) {
+    const accounts = await this.accountInfo.getCurrent();
+    if (!isAddressEqual(accounts[0].address, address)) {
+      throw new Error("address is not the current account");
+    }
     const signature = await this.accountInfo.signMessage(message);
-    return {
-      message: MSG_PREFIX + message,
-      signature,
-      publicKey: publicKey || currentAddress
-    };
+    return signature;
   }
-  async signIn(params) {
-    const { address: currentAddress, publicKey } = await this.accountInfo.getCurrent();
-    const { signature = "" } = await this.signMessage(params);
-    return {
-      address: currentAddress,
-      publicKey: publicKey || currentAddress,
-      signature,
-      signedMessage: MSG_PREFIX + params.message
-    };
+  async eth_signTypedData_v4([address, typedData]) {
+    const accounts = await this.accountInfo.getCurrent();
+    if (!isAddressEqual(accounts[0].address, address)) {
+      throw new Error("address is not the current account");
+    }
+    const signature = await this.accountInfo.signTypedData(typedData);
+    return signature;
   }
-  async request({ method, params }) {
-    if (!this[method]) {
-      throw new Error(`${method} in request is not supported`);
+  async eth_getBalance([address, type]) {
+    const accounts = await this.accountInfo.getCurrent();
+    if (!isAddressEqual(accounts[0].address, address)) {
+      throw new Error("address is not the current account");
+    }
+    if (type !== "latest") {
+      throw new Error("type is not supported");
+    }
+    const chainInfo = await this.getCurrentChain();
+    const { rpcClient } = getRPCClient(chainInfo);
+    try {
+      const balance = await rpcClient.getBalance({ address });
+      return balance?.toString() || "0";
+    } catch (error) {
+      console.error(error);
+      return "0";
     }
-    return this[method](params);
   }
   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);
-      callData = "0x" + txToHex(transaction);
-    } else {
-      const transaction = await createLegacyTx(txData, this.connection);
-      callData = "0x" + txToHex(transaction);
+      callData = createErc20TxData(txData, { decimals, address: tokenAddress })?.data;
     }
     const gasLimitParam = {
       from: txData.from,
@@ -4500,8 +4881,9 @@ var SolanaService = class _SolanaService extends BaseService {
       params: queryGasParams
     });
     if (!success) {
-      console.error("queryGasInfo solana", txData, message, gasInfo);
-      const { gasFee } = BaseConfig;
+      console.error("queryGasInfo evm", txData, queryGasParams, message, gasInfo);
+      const BaseConfig3 = SupportedChainTypes[ChainTypes.EVM];
+      const { gasFee } = BaseConfig3;
       return {
         success: true,
         gasFee: gasFee.toString()
@@ -4510,528 +4892,326 @@ var SolanaService = class _SolanaService extends BaseService {
     const nativeChainId = SupportedChainTypes[this.chainType].chainId;
     const { nativeCurrency } = await this.networks.getNetworkByChainId(nativeChainId);
     const { baseFee = 1, gasLimit = 0 } = gasInfo;
-    const baseFeeBN = new BigNumber(baseFee).times(2);
-    const gasLimitBN = new BigNumber(gasLimit);
+    const baseFeeBN = new BigNumber(baseFee);
     const calcFee = (feeLevel) => {
-      const priorityFee = gasLimitBN.times(gasInfo[feeLevel] || 0).dividedBy(1e6).integerValue(BigNumber.ROUND_DOWN);
-      const gasFee = baseFeeBN.plus(priorityFee);
+      const fee = baseFeeBN.plus(gasInfo[feeLevel] || 0);
+      const gasFee = fee.times(gasLimit);
       return formatUnits(BigInt(gasFee.toNumber()), nativeCurrency?.decimals || 9);
     };
     return {
-      success: true,
+      success,
       fees: {
         low: calcFee("priorityFeeLow"),
         medium: calcFee("priorityFeeMedium"),
         high: calcFee("priorityFeeHigh")
       },
-      gasFee: calcFee("priorityFeeHigh")
-    };
-  }
-  async sendSignedTx(signedTx) {
-    let rawTx;
-    try {
-      const hexBuffer = Buffer.from(signedTx, "hex");
-      VersionedTransaction.deserialize(hexBuffer);
-      rawTx = hexBuffer;
-    } catch (error) {
-      const base58Buffer = Buffer.from(toBase58());
-      VersionedTransaction.deserialize(base58Buffer);
-      rawTx = base58Buffer;
-    }
-    const transaction = VersionedTransaction.deserialize(rawTx);
-    if (!transaction.signatures || transaction.signatures.length === 0) {
-      throw new Error("lack of sign");
-    }
-    const confirmationStrategy = {
-      commitment: "confirmed",
-      preflightCommitment: "processed",
-      skipPreflight: false,
-      maxRetries: 5
-    };
-    try {
-      const simulation = await this.connection.simulateTransaction(transaction);
-      if (simulation.value.err) {
-        const logs = simulation.value.logs || [];
-        const message = logs[logs.length - 1] || simulation.value.err || "Unknown error occurred";
-        console.error("send err logs:", logs, message);
-        throw new Error(`Transaction failed: ${message}`);
-      }
-      const signature = await sendAndConfirmRawTransaction(this.connection, rawTx, confirmationStrategy);
-      return signature;
-    } catch (error) {
-      if (error.message.includes("TransactionExpiredTimeoutError")) {
-        const status = await this.connection.getSignatureStatus(transaction.signatures[0].toString());
-        if (status.value?.confirmationStatus === "confirmed") {
-          return transaction.signatures[0].toString();
-        }
-      }
-      throw error;
-    }
-  }
-  async signTransaction({ rawTransaction }) {
-    const params = {
-      rawTransaction,
-      walletId: -1,
-      rpcUrl: this.rpcUrl
-    };
-    const signature = await this.accountInfo.signTransaction(JSON.stringify(params));
-    return signature;
-  }
-  async signAndSendTransaction({ rawTransaction }) {
-    const signedTx = await this.signTransaction({ rawTransaction });
-    if (!signedTx) {
-      return "";
-    }
-    const signature = await this.sendSignedTx(signedTx);
-    return signature;
-  }
-  async signAllTransactions({ rawTransactions }) {
-    throw new Error("no support");
-  }
-  async signAndSendAllTransactions({ rawTransactions }) {
-    throw new Error("no support");
-  }
-  async queryRent(params) {
-    const MIN_ACCOUNT_ACTIVATION_SOL = "0.0009";
-    const SPL_TOKEN_ACCOUNT_CREATION_FEE = "0.001";
-    try {
-      const { toAddress, tokenAddress } = params;
-      let minTransferAmount = "0";
-      let createSplTokenFee = null;
-      if (tokenAddress) {
-        const tokenAccountExists = await this.checkTokenAccount(toAddress, tokenAddress);
-        if (!tokenAccountExists) {
-          createSplTokenFee = SPL_TOKEN_ACCOUNT_CREATION_FEE;
-        }
-      } else {
-        const accountExists = await this.checkAccountExists(toAddress);
-        if (!accountExists) {
-          minTransferAmount = MIN_ACCOUNT_ACTIVATION_SOL;
-        }
+      gasFee: calcFee("priorityFeeMedium"),
+      baseFee,
+      gasLimit,
+      priorityFee: {
+        low: gasInfo.priorityFeeLow,
+        medium: gasInfo.priorityFeeMedium,
+        high: gasInfo.priorityFeeHigh
       }
-      const rentInfo = {
-        minTransferAmount,
-        createSplTokenFee
-      };
-      return rentInfo;
-    } catch (error) {
-      console.error("queryRent error:", error);
-      const defaultRentInfo = {
-        minTransferAmount: "0",
-        createSplTokenFee: null
-      };
-      return defaultRentInfo;
-    }
+    };
   }
-  async checkAccountExists(address) {
-    try {
-      const accountInfo = await this.connection.getAccountInfo(new PublicKey(address));
-      return accountInfo !== null;
-    } catch (error) {
-      console.warn("Failed to check account exists:", error);
-      return false;
+  async createPublicClient({ chainId, rpcUrl }) {
+    if (rpcUrl) {
+      return createPublicClient({
+        transport: http(rpcUrl)
+      });
+    }
+    if (chainId) {
+      this.networks.setChainType(this.chainType);
+      const chainInfo = await this.networks.getNetworkByChainId(chainId);
+      rpcUrl = chainInfo.rpcUrls[0];
+    } else {
+      const chainInfo = await this.getCurrentChain();
+      rpcUrl = chainInfo.rpcUrls[0];
+    }
+    if (!rpcUrl) {
+      throw new Error("rpcUrl is not set");
     }
+    return createPublicClient({
+      transport: http(rpcUrl)
+    });
   }
-  async checkTokenAccount(ownerAddress, tokenMint) {
+  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 owner = new PublicKey(ownerAddress);
-      const mint = new PublicKey(tokenMint);
-      const associatedTokenAddress = await getAssociatedTokenAddress(mint, owner);
-      const accountInfo = await this.connection.getAccountInfo(associatedTokenAddress);
-      return accountInfo !== null;
+      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 check token account:", error);
-      return false;
+      console.warn("Failed to estimate gas:", error);
+      const BaseConfig3 = SupportedChainTypes[ChainTypes.EVM];
+      const { gasFee } = BaseConfig3;
+      return numberToHex(parseUnits(gasFee.toString(), 18));
     }
   }
-};
-var BaseConfig2 = SupportedChainTypes[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 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);
+  // Get nonce for current account
+  async eth_getTransactionCount([address, type]) {
+    const accounts = await this.accountInfo.getCurrent();
+    if (accounts[0].address !== address) {
+      throw new Error("address is not the current account");
     }
-    for (const output of tx.outputs) {
-      psbt.addOutput({
-        value: output.amount,
-        address: output.address
-      });
+    if (type !== "latest" && type !== "pending") {
+      throw new Error("type is not supported");
     }
-    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 = 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).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$1 = address.fromOutputScript(output.script, network);
-          psbt.addOutput({
-            address: address$1,
-            value: Number(output.value)
-          });
-        } catch (error) {
-          psbt.addOutput({
-            script: output.script,
-            value: Number(output.value)
-          });
-        }
-      }
-      const psbtHex = psbt.toHex();
-      return toBase64(fromHex3(psbtHex));
+      const rpcClient = await this.createPublicClient({});
+      const nonce = await rpcClient.getTransactionCount({ address });
+      return nonce;
     } catch (error) {
-      console.warn("rawTxToPsbtBase64 failed:", error);
-      throw new Error(
-        `Failed to convert raw transaction to PSBT: ${error instanceof Error ? error.message : String(error)}`
-      );
+      console.error("Failed to get nonce:", error);
+      throw new Error(`Failed to get nonce: ${error}`);
     }
   }
-};
-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");
+  //https://docs.metamask.io/snaps/reference/keyring-api/chain-methods/#eth_signtransaction
+  async eth_signTransaction(txParams) {
+    const preparedTxPropsType = {
+      chainId: "number",
+      to: "string",
+      value: "bigint",
+      data: "string",
+      nonce: "number",
+      maxPriorityFeePerGas: "bigint",
+      maxFeePerGas: "bigint",
+      gasPrice: "bigint",
+      gas: "bigint"
+    };
+    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");
     }
-    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");
+    const accounts = await this.accountInfo.getCurrent();
+    const address = accounts[0].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 = {
+      gas: txData?.gas
+    };
+    for (const key in preparedTxPropsType) {
+      if (txData?.[key] && isHex(txData?.[key])) {
+        preparedTx[key] = preparedTxPropsType[key] === "number" ? fromHex$1(txData[key], "number") : txData[key];
+      }
+    }
+    if (txData?.type !== "legacy") {
+      delete preparedTx.gasPrice;
     }
-    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);
-}
-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 serializedTransaction = await this.accountInfo.signTransaction(
+        JSON.stringify({
+          data: preparedTx,
+          types: preparedTxPropsType
+        })
+      );
+      if (serializedTransaction === "") {
+        throw new Error(`eth_signTransaction error data: ${JSON.stringify(txParams)}`);
+      }
+      const data = parseTransaction(serializedTransaction);
+      return data;
+    } catch (err) {
+      throw new Error("eth_signTransaction error" + err);
     }
-  });
-  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
+  }
+  async eth_sendRawTransaction([serializedTransaction], rpcUrl) {
+    try {
+      const rpcClient = await this.createPublicClient({ rpcUrl });
+      const hash = await rpcClient.sendRawTransaction({
+        serializedTransaction
       });
-      usingUtxos[txid] = 1;
-      addedAmount += Number(outputValue);
+      return hash;
+    } catch (error) {
+      console.error("Failed to send transaction via RPC:", error, rpcUrl);
+      throw error;
     }
   }
-  if (addedAmount < totalNeeded) {
-    throw new Error("not enough funds to cover amount and fee");
-  }
-  const outputs = [
-    {
-      address: to,
-      amount: sendAmount
+  async getTransaction(hash) {
+    if (!hash || !isHex(hash)) {
+      throw new Error("txId is not valid");
+    }
+    try {
+      const rpcClient = await this.createPublicClient({});
+      const tx = await rpcClient.getTransaction({
+        hash
+      });
+      return tx;
+    } catch (error) {
+      console.error("Failed to send transaction via RPC:", error, hash);
+      throw error;
     }
-  ];
-  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.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 {};
+};
+var BaseConfig2 = SupportedChainTypes[ChainTypes.SOL];
+var TOKEN_METADATA_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
+var MSG_PREFIX = "\xFFsolana offchain";
+
+// src/solana/utils.ts
+__toESM(require_bn());
+new PublicKey(TOKEN_METADATA_PROGRAM_ID);
+var txToHex = (tx) => {
+  if (tx instanceof VersionedTransaction) {
+    return Buffer.from(tx.serialize()).toString("hex");
   }
-  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";
-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);
+  if (tx instanceof Transaction$1) {
+    return Buffer.from(
+      tx.serialize({
+        requireAllSignatures: false,
+        verifySignatures: false
+      })
+    ).toString("hex");
   }
-  result.push(
-    ...utxos.map((i) => ({
-      txid: i.txid,
-      vout: i.vout,
-      outputValue: i.satoshis,
-      script: i.script_pubkey,
-      ...filter === "inscriptions"
-    }))
+  return tx;
+};
+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$1().add(
+    SystemProgram.transfer({
+      fromPubkey,
+      //payer
+      toPubkey,
+      //toAccount
+      lamports: amount * LAMPORTS_PER_SOL
+    })
   );
-  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;
+  transaction.feePayer = fromPubkey;
+  transaction.recentBlockhash = blockhash;
+  transaction.lastValidBlockHeight = lastValidBlockHeight;
+  return transaction;
 }
-var DuneDetailsCacheKey = "DuneDetails";
-cache.get(DuneDetailsCacheKey) || {};
-var sendDogeTx = async (rawTx) => {
+async function createTokenLegacyTransaction2({
+  from = "",
+  to = "",
+  amount = 0,
+  tokenAddress = "",
+  priorityFee = 0,
+  // microLamports (1 SOL = 1e6 microLamports)
+  decimals = 6
+}, connection) {
   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);
+    const fromPubkey = new PublicKey(from);
+    const toPubkey = new PublicKey(to);
+    const tokenPublicKey = new PublicKey(tokenAddress);
+    const fromTokenPubKey = await getAssociatedTokenAddress(tokenPublicKey, fromPubkey);
+    const toTokenPubKey = await getAssociatedTokenAddress(tokenPublicKey, toPubkey);
+    const { blockhash } = await connection.getLatestBlockhash("confirmed");
+    const transaction = new Transaction$1();
+    transaction.feePayer = fromPubkey;
+    transaction.recentBlockhash = blockhash;
+    try {
+      const instruction = createAssociatedTokenAccountInstruction(fromPubkey, toTokenPubKey, toPubkey, tokenPublicKey);
+      transaction.add(instruction);
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+    const tokenAmount = new Bignumber(amount).multipliedBy(new Bignumber(10).pow(decimals)).toNumber();
+    transaction.add(
+      createTransferInstruction(fromTokenPubKey, toTokenPubKey, fromPubkey, tokenAmount, [], TOKEN_PROGRAM_ID)
+    );
+    return transaction;
+  } catch (error) {
+    console.error("Error creating transaction:", error);
+    throw error;
   }
-};
-
-// src/dogecoin/service.ts
-var DogecoinService = class _DogecoinService extends BaseService {
+}
+var SolanaService = class _SolanaService extends BaseService {
   static instance;
   chainType;
+  rpcUrl;
+  connection;
   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
+    const config = {
+      commitment: "confirmed",
+      disableRetryOnRateLimit: false,
+      confirmTransactionInitialTimeout: 12e4,
+      fetch: (url, options) => {
+        return fetch(url, { ...options });
+      }
     };
+    const domain = TomoApiDomains[tomoAppInfo.tomoStage];
+    const rpcUrl = `${domain}/rpc/v1/solana`;
+    this.rpcUrl = rpcUrl;
+    this.connection = new Connection(rpcUrl, config);
   }
-  async getBalance() {
-    const addresses = await this.accountInfo.getCurrent();
-    const { address } = addresses?.[0] || {};
-    if (!address) {
-      throw new Error("address is not set");
+  static getInstance(chainType, accountInfo, tomoAppInfo) {
+    if (!_SolanaService.instance) {
+      _SolanaService.instance = new _SolanaService(chainType, accountInfo, tomoAppInfo);
     }
-    const { balance = 0 } = await getBalance(address);
-    return {
-      address,
-      balance
-    };
+    return _SolanaService.instance;
   }
-  async signMessage({ message, type }) {
-    if (type) {
-      throw new Error("bip322simple not support.");
-    }
+  async getCurrentWalletAccount() {
+    return await this.accountInfo.getCurrent();
+  }
+  async getAccount() {
+    const { address: currentAddress, publicKey } = await this.accountInfo.getCurrent();
+    return { publicKey: publicKey || currentAddress, address: currentAddress };
+  }
+  async signMessage(params) {
+    const { address: currentAddress, publicKey } = await this.accountInfo.getCurrent();
+    const { message } = params;
     const signature = await this.accountInfo.signMessage(message);
     return {
-      signedMessage: signature
+      message: MSG_PREFIX + message,
+      signature,
+      publicKey: publicKey || currentAddress
     };
   }
-  async requestSignedMessage({
-    message,
-    type
-  }) {
-    return await this.signMessage({
-      message,
-      type
-    });
+  async signIn(params) {
+    const { address: currentAddress, publicKey } = await this.accountInfo.getCurrent();
+    const { signature = "" } = await this.signMessage(params);
+    return {
+      address: currentAddress,
+      publicKey: publicKey || currentAddress,
+      signature,
+      signedMessage: MSG_PREFIX + params.message
+    };
   }
-  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 request({ method, params }) {
+    if (!this[method]) {
+      throw new Error(`${method} in request is not supported`);
     }
+    return this[method](params);
   }
   async _queryGasInfo(txData) {
-    const { chainId, amount = 0, decimals = 8 } = txData;
+    const { tokenAddress, chainId, amount = 0, decimals = 9 } = txData;
+    const value = tokenAddress ? "0x1" : toHex$1(parseUnits(amount.toString(), decimals));
+    let callData = "0x";
+    if (tokenAddress) {
+      const transaction = await createTokenLegacyTransaction2(txData, this.connection);
+      callData = "0x" + txToHex(transaction);
+    } else {
+      const transaction = await createLegacyTx(txData, this.connection);
+      callData = "0x" + txToHex(transaction);
+    }
     const gasLimitParam = {
       from: txData.from,
       to: txData.to,
-      value: toHex(parseUnits(amount.toString(), decimals))
+      value
     };
     const queryGasParams = {
-      chainIndex: Number(chainId || BaseConfig2.chainId),
-      callData: "0x",
+      chainIndex: Number(chainId),
+      callData,
       gasLimitParam,
       addressList: [txData.from]
     };
@@ -5044,85 +5224,149 @@ var DogecoinService = class _DogecoinService extends BaseService {
       params: queryGasParams
     });
     if (!success) {
-      console.error("queryGasInfo doge", success, txData, queryGasParams, gasInfo);
+      console.error("queryGasInfo solana", txData, message, gasInfo);
       const { gasFee } = BaseConfig2;
       return {
         success: true,
         gasFee: gasFee.toString()
       };
     }
-    const { baseFee = 1, gasLimit = 1 } = gasInfo;
+    const nativeChainId = SupportedChainTypes[this.chainType].chainId;
+    const { nativeCurrency } = await this.networks.getNetworkByChainId(nativeChainId);
+    const { baseFee = 1, gasLimit = 0 } = gasInfo;
+    const baseFeeBN = new BigNumber(baseFee).times(2);
+    const gasLimitBN = new BigNumber(gasLimit);
     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")
+      const priorityFee = gasLimitBN.times(gasInfo[feeLevel] || 0).dividedBy(1e6).integerValue(BigNumber.ROUND_DOWN);
+      const gasFee = baseFeeBN.plus(priorityFee);
+      return formatUnits(BigInt(gasFee.toNumber()), nativeCurrency?.decimals || 9);
     };
     return {
       success: true,
-      fees,
-      gasFee: fees.high
+      fees: {
+        low: calcFee("priorityFeeLow"),
+        medium: calcFee("priorityFeeMedium"),
+        high: calcFee("priorityFeeHigh")
+      },
+      gasFee: calcFee("priorityFeeHigh")
     };
   }
-  async requestPsbt({
-    rawTx,
-    signOnly
-  }) {
-    const psbtBase64 = await DogecoinUtils.rawTxToPsbtBase64(rawTx);
-    const signedPsbt = await this.accountInfo.signTransaction(JSON.stringify({ psbtBase64 }));
-    if (!signedPsbt) {
-      return null;
+  async sendSignedTx(signedTx) {
+    let rawTx;
+    try {
+      const hexBuffer = Buffer.from(signedTx, "hex");
+      VersionedTransaction.deserialize(hexBuffer);
+      rawTx = hexBuffer;
+    } catch (error) {
+      const base58Buffer = Buffer.from(toBase58());
+      VersionedTransaction.deserialize(base58Buffer);
+      rawTx = base58Buffer;
     }
-    const signedRawTx = DogecoinUtils.extractPsbtTransaction(signedPsbt, 1e5);
-    if (signOnly) {
-      return {
-        signedRawTx
-      };
+    const transaction = VersionedTransaction.deserialize(rawTx);
+    if (!transaction.signatures || transaction.signatures.length === 0) {
+      throw new Error("lack of sign");
     }
-    const { txid = "" } = await sendDogeTx(signedRawTx);
-    return {
-      txId: txid,
-      signedRawTx
+    const confirmationStrategy = {
+      commitment: "confirmed",
+      preflightCommitment: "processed",
+      skipPreflight: false,
+      maxRetries: 5
     };
-  }
-  async requestTransaction(txData) {
-    const spendableUtxos = txData?.spendableUtxos;
-    if (txData.amountMismatch) {
-      throw new Error("balance_insufficient");
+    try {
+      const simulation = await this.connection.simulateTransaction(transaction);
+      if (simulation.value.err) {
+        const logs = simulation.value.logs || [];
+        const message = logs[logs.length - 1] || simulation.value.err || "Unknown error occurred";
+        console.error("send err logs:", logs, message);
+        throw new Error(`Transaction failed: ${message}`);
+      }
+      const signature = await sendAndConfirmRawTransaction(this.connection, rawTx, confirmationStrategy);
+      return signature;
+    } catch (error) {
+      if (error.message.includes("TransactionExpiredTimeoutError")) {
+        const status = await this.connection.getSignatureStatus(transaction.signatures[0].toString());
+        if (status.value?.confirmationStatus === "confirmed") {
+          return transaction.signatures[0].toString();
+        }
+      }
+      throw error;
     }
-    if (!spendableUtxos || spendableUtxos?.length === 0) {
-      txData.spendableUtxos = await getSpendableUtxos(txData.from);
+  }
+  async signTransaction({ rawTransaction }) {
+    const params = {
+      rawTransaction,
+      walletId: -1,
+      rpcUrl: this.rpcUrl
+    };
+    const signature = await this.accountInfo.signTransaction(JSON.stringify(params));
+    return signature;
+  }
+  async signAndSendTransaction({ rawTransaction }) {
+    const signedTx = await this.signTransaction({ rawTransaction });
+    if (!signedTx) {
+      return "";
     }
-    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.");
+    const signature = await this.sendSignedTx(signedTx);
+    return signature;
+  }
+  async signAllTransactions({ rawTransactions }) {
+    throw new Error("no support");
+  }
+  async signAndSendAllTransactions({ rawTransactions }) {
+    throw new Error("no support");
+  }
+  async queryRent(params) {
+    const MIN_ACCOUNT_ACTIVATION_SOL = "0.0009";
+    const SPL_TOKEN_ACCOUNT_CREATION_FEE = "0.001";
+    try {
+      const { toAddress, tokenAddress } = params;
+      let minTransferAmount = "0";
+      let createSplTokenFee = null;
+      if (tokenAddress) {
+        const tokenAccountExists = await this.checkTokenAccount(toAddress, tokenAddress);
+        if (!tokenAccountExists) {
+          createSplTokenFee = SPL_TOKEN_ACCOUNT_CREATION_FEE;
+        }
+      } else {
+        const accountExists = await this.checkAccountExists(toAddress);
+        if (!accountExists) {
+          minTransferAmount = MIN_ACCOUNT_ACTIVATION_SOL;
+        }
+      }
+      const rentInfo = {
+        minTransferAmount,
+        createSplTokenFee
+      };
+      return rentInfo;
+    } catch (error) {
+      console.error("queryRent error:", error);
+      const defaultRentInfo = {
+        minTransferAmount: "0",
+        createSplTokenFee: null
+      };
+      return defaultRentInfo;
     }
+  }
+  async checkAccountExists(address) {
     try {
-      const { txid } = await sendDogeTx(signedTx);
-      addUsedUtxos(usingUtxos);
-      return { txId: txid };
-    } catch (err) {
-      throw new Error("Error: send transaction err." + JSON.stringify(err));
+      const accountInfo = await this.connection.getAccountInfo(new PublicKey(address));
+      return accountInfo !== null;
+    } catch (error) {
+      console.warn("Failed to check account exists:", error);
+      return false;
     }
   }
-  async getTransactionStatus({ txId }) {
-    const transaction = await getTxDetail(txId);
-    if (!transaction?.txid) {
-      return null;
+  async checkTokenAccount(ownerAddress, tokenMint) {
+    try {
+      const owner = new PublicKey(ownerAddress);
+      const mint = new PublicKey(tokenMint);
+      const associatedTokenAddress = await getAssociatedTokenAddress(mint, owner);
+      const accountInfo = await this.connection.getAccountInfo(associatedTokenAddress);
+      return accountInfo !== null;
+    } catch (error) {
+      console.warn("Failed to check token account:", error);
+      return false;
     }
-    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 {
@@ -5216,4 +5460,4 @@ var ChainTypeServices = {
   [ChainTypes.DOGE]: DogecoinService
 };
 
-export { AccountType, ChainTypeServices, DogecoinService, 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 };