@tomo-inc/chains-service 0.0.7 → 0.0.8

package/src/dogecoin/utils.ts

@@ -4,8 +4,7 @@ import { DogecoinUtils } from "./utils-doge";
 
 import * as API from "./rpc";
 
-import { ChainTypes, SupportedChainTypes } from "@tomo-inc/wallet-utils";
-import { DECIMALS, RPC_URL, network } from "./config";
+import { DECIMALS, network } from "./config";
 import { DogeSpendableUtxos } from "./type";
 
 import * as base from "./base";
@@ -14,14 +13,6 @@ import { Psbt } from "bitcoinjs-lib";
 
 const KOINU_PER_DOGE = new BigNumber(DECIMALS); // 10^8
 
-export async function waitOnly(ms: number) {
-  return new Promise((resolve, reject) => {
-    setTimeout(() => {
-      resolve(ms);
-    }, ms);
-  });
-}
-
 export function toSatoshi(bitcion: number | string): number {
   try {
     const amount = new BigNumber(bitcion);
@@ -46,103 +37,6 @@ export function toBitcoin(satoshis: number | string): number {
   }
 }
 
-export const isDogeCoin = (token: any = {}, network: any = {}) => {
-  return token?.address === "" && (network?.chainId === "3" || network?.chainId === "221122420");
-};
-
-export const isDogeOSDevnet = (network: any = {}) => {
-  return network?.chainId === "221122420";
-};
-
-export const isDogeMainnet = (network: any = {}) => {
-  return network?.chainId === "3";
-};
-
-export const isHasDoge = (balances: any) => {
-  return !!balances?.[300];
-};
-
-export const isDogeChain = (network: any = {}) => {
-  const { chainType, chainIndex } = network;
-  return chainType === ChainTypes.DOGE && chainIndex === SupportedChainTypes[ChainTypes.DOGE].chainIndex;
-};
-
-export function hexToBase64(hex: string): string {
-  try {
-    return base?.toBase64(base?.fromHex(hex));
-  } catch (error) {
-    console.error("PSBT hex to base64 failed:", error);
-    throw error;
-  }
-}
-
-export function base64ToHex(base64: string): string {
-  try {
-    return base?.toHex(base?.fromBase64(base64));
-  } catch (error) {
-    console.error("PSBT base64 to hex failed:", error);
-    throw error;
-  }
-}
-
-export const Drc20LargeNumber = (n: number) => {
-  const num = n || 0;
-
-  if (num >= 1000 && num < 1000000) {
-    return num.toLocaleString();
-  }
-
-  if (num >= 1000000) {
-    return formatCompactNumber(num, 1);
-  }
-
-  return num.toString();
-};
-
-//from mydoge
-export const formatCompactNumber = (num = 0, decimals = 1) => {
-  const suffixes = ["", "k", "m", "billion", "trillion"];
-  const absNum = Math.abs(num);
-
-  if (absNum < 1000) return num.toFixed(decimals);
-
-  const exp = Math.min(Math.floor(Math.log10(absNum) / 3), suffixes.length - 1);
-  const shortened = num / 1000 ** exp;
-
-  return `${shortened.toLocaleString(undefined, {
-    minimumFractionDigits: 0,
-    maximumFractionDigits: decimals,
-  })} ${suffixes[exp]}`;
-};
-
-//from mydoge
-export function formatSatoshisAsDoge(value: number, maxDecimals?: number): string {
-  if (value >= 1) {
-    const newValue = toBitcoin(Math.floor(value));
-    return formatDoge(newValue, maxDecimals);
-  } else {
-    return formatDoge(value / 1e8, 10);
-  }
-}
-
-//from mydoge
-export function formatDoge(value: number | string, maxDecimals?: number, useGrouping?: any): string {
-  let newValue = value;
-  const opts: any = {};
-  if (maxDecimals !== undefined) {
-    opts.maximumFractionDigits = maxDecimals;
-  }
-  if (useGrouping !== undefined) {
-    opts.useGrouping = useGrouping;
-  }
-  // show 4.20 instead of 4.2
-  if (newValue === 4.2) {
-    opts.minimumFractionDigits = 2;
-  }
-  newValue = newValue.toLocaleString(undefined, opts);
-  return newValue;
-}
-
 export function addUsedUtxos(newUsedUtxos: object) {
   const usedUtxos = cache.get("UsedUtxos") || {};
   for (const txid in newUsedUtxos) {
@@ -155,107 +49,6 @@ export function getUsedUtxos() {
   return cache.get("UsedUtxos") || {};
 }
 
-export async function createInscriptionPsbt({
-  inscriptionId,
-  senderAddress,
-  recipientAddress,
-  utxos,
-  fee,
-  amount,
-  location,
-}: any) {
-  const inscription = await API.getTxDetail(inscriptionId);
-
-  let vout = inscription.vout[0]?.n;
-  if (location) {
-    const locations = location.split(":");
-    vout = Number(locations[1] || vout);
-  }
-
-  const inputs = [
-    {
-      txId: inscriptionId,
-      vOut: vout,
-      amount: toSatoshi(amount),
-      nonWitnessUtxo: inscription.hex,
-      address: senderAddress,
-    },
-  ];
-
-  const sendCost = toSatoshi(fee);
-
-  const usedUtxos = getUsedUtxos();
-  const sortedUtxos = utxos.sort((a: any, b: any) => b.outputValue - a.outputValue);
-
-  // First pass: collect sufficient UTXOs to cover the fee
-  const selectedUtxos = [];
-  let accumulatedAmount = 0;
-
-  for (const utxo of sortedUtxos) {
-    const { txid } = utxo;
-    if (accumulatedAmount >= sendCost || usedUtxos[txid]) continue;
-
-    selectedUtxos.push(utxo);
-    accumulatedAmount += Number(utxo.outputValue);
-  }
-
-  // Second pass: concurrently fetch UTXO details
-  const utxoDetailPromises = selectedUtxos.map(async (utxo) => {
-    try {
-      const utxoDetail = await API.getTxDetail(utxo.txid);
-      return { utxo, utxoDetail };
-    } catch (error) {
-      return { utxo, utxoDetail: null };
-    }
-  });
-
-  const utxoResults = await Promise.all(utxoDetailPromises);
-
-  // Third pass: construct inputs from successfully fetched details
-  const usingUtxos: any = {};
-  let addedAmount = 0;
-
-  for (const { utxo, utxoDetail } of utxoResults) {
-    if (addedAmount >= sendCost) break;
-
-    const { txid, vout, outputValue, address = senderAddress } = utxo;
-
-    if (utxoDetail?.hex && !usedUtxos[txid] && !usingUtxos[txid]) {
-      inputs.push({
-        txId: txid,
-        vOut: vout,
-        amount: Number(outputValue),
-        nonWitnessUtxo: utxoDetail.hex,
-        address,
-      });
-      usingUtxos[txid] = 1;
-      addedAmount += Number(outputValue);
-    }
-  }
-
-  if (addedAmount < sendCost) {
-    throw new Error("not enough funds to cover amount and fee");
-  }
-
-  const params: any = {
-    address: senderAddress,
-    inputs,
-    outputs: [
-      {
-        address: recipientAddress,
-        amount: toSatoshi(amount),
-      },
-      {
-        address: senderAddress,
-        amount: addedAmount - sendCost,
-      },
-    ],
-  };
-
-  const psbtBase64 = DogecoinUtils.buildPsbtToBase64(params);
-  return { psbtBase64, usingUtxos };
-}
-
 export async function createPsbt({
   from,
   to,
@@ -269,9 +62,9 @@ export async function createPsbt({
   fee: number;
   spendableUtxos: DogeSpendableUtxos[];
 }) {
-  let utxos = spendableUtxos;
+  const utxos = spendableUtxos;
   if (!utxos || utxos.length === 0) {
-    utxos = await API.getSpendableUtxos(from);
+    throw new Error("no spendable utxos");
   }
 
   const sendAmount = toSatoshi(amount);
@@ -359,176 +152,6 @@ export async function createPsbt({
   return { psbtBase64, usingUtxos };
 }
 
-export async function createTxData(txInfo: any, senderAddress: string) {
-  let txData = {
-    ...txInfo,
-    ...{
-      sender: senderAddress,
-      feeRate: 1,
-      amountMismatch: false,
-    },
-  };
-
-  try {
-    const { feePerKB }: any = await API.estimateSmartFee({ senderAddress });
-    const { balance = 0 } = await API.getBalance(senderAddress);
-    let amountMismatch = false;
-    const balanceBN = new BigNumber(balance);
-    const amountBN = new BigNumber(Number(txInfo.amount)).times(DECIMALS);
-    if (balanceBN < amountBN.plus(feePerKB)) {
-      amountMismatch = true;
-    }
-
-    txData = {
-      ...txInfo,
-      ...{
-        sender: senderAddress,
-        feeRate: feePerKB,
-        amountMismatch,
-      },
-    };
-  } catch (err) {
-    console.error(err);
-  }
-  return txData;
-}
-
-export function createSocialTxData(data: any, account: any) {
-  const senderAddress = data.senderAddress || data.sender || data.from || data.fromAddress;
-  const fee = data.fee || data.feeRate || 0;
-  return {
-    from: senderAddress,
-    to: data.to,
-    amount: Number(data.amount),
-    fee: toSatoshi(fee),
-    // accountId: account?.id,
-    walletId: -1,
-    rpcUrl: data.rpcUrl || RPC_URL,
-  };
-}
-
-export interface DogeTxData {
-  amountMismatch?: boolean;
-  amount: number;
-  fee: number;
-  to: string;
-  from: string;
-  senderAddress?: string;
-  sender?: string;
-  fromAddress?: string;
-  spendableUtxos?: DogeSpendableUtxos[];
-}
-export async function createBtcTxData(txData: DogeTxData) {
-  const transferAmount = toSatoshi(txData.amount);
-  const feeAmount = toSatoshi(txData.fee);
-  const senderAddress = txData.senderAddress || txData.sender || txData.from || txData.fromAddress;
-
-  const usedUtxos = getUsedUtxos();
-  const usingUtxos: any = {};
-
-  let utxos = txData.spendableUtxos;
-  if (!utxos || utxos.length === 0) {
-    throw new Error("No spendable UTXOs available");
-  }
-
-  utxos = utxos.sort((a, b) => b.outputValue - a.outputValue);
-
-  const requiredAmount = transferAmount + feeAmount;
-  let total = 0;
-  const inputs = [];
-
-  // select enough UTXOs
-  for (const utxo of utxos) {
-    if (total >= requiredAmount) break;
-
-    if (!usedUtxos[utxo.txid]) {
-      inputs.push({
-        txId: utxo.txid,
-        vOut: utxo.vout,
-        amount: Number(utxo.outputValue),
-      });
-      usingUtxos[utxo.txid] = 1;
-      total += Number(utxo.outputValue);
-    }
-  }
-
-  // check balance
-  if (total < requiredAmount) {
-    throw new Error("Insufficient funds");
-  }
-
-  const outputs = [
-    {
-      address: txData.to,
-      amount: transferAmount,
-    },
-  ];
-
-  const txParams = {
-    inputs,
-    outputs,
-    address: senderAddress, // charge
-    feePerB: 100000,
-  };
-
-  return { params: txParams, usingUtxos };
-}
-
-export function createDrc20Data(utxos: any[], senderAddress: string, inscription: string) {
-  if (!utxos || utxos.length === 0) {
-    throw new Error("UTXOs are required");
-  }
-  if (!senderAddress) {
-    throw new Error("Sender address is required");
-  }
-  if (!inscription) {
-    throw new Error("Inscription data is required");
-  }
-
-  const commitTxPrevOutputList = [];
-  const usedUtxos = getUsedUtxos();
-  const usingUtxos: any = {};
-
-  const txFeeDefault = 30000000; //0.3 DOGE
-  let addedAmount = 0;
-  utxos = utxos.sort((a, b) => b.outputValue - a.outputValue);
-  for (const utxo of utxos) {
-    const { txid, vout, outputValue, address = senderAddress } = utxo;
-    if (addedAmount < txFeeDefault && !usedUtxos[txid]) {
-      commitTxPrevOutputList.push({
-        txId: txid,
-        vOut: vout,
-        amount: Number(outputValue),
-        address,
-      });
-      usingUtxos[txid] = 1;
-      addedAmount += Number(outputValue);
-    }
-  }
-
-  if (addedAmount < txFeeDefault) {
-    throw new Error("insufficient balance.");
-  }
-
-  // const inscriptionHex = base.toHex(Buffer.from(inscription));
-  const inscriptionData = {
-    contentType: "text/plain;charset=utf8",
-    body: inscription,
-    revealAddr: senderAddress,
-  };
-
-  const request = {
-    type: 1,
-    commitTxPrevOutputList,
-    commitFeeRate: 10000,
-    revealFeeRate: 9000,
-    revealOutValue: 0,
-    inscriptionData,
-    changeAddress: senderAddress,
-  };
-  return { params: request, usingUtxos };
-}
-
 export function decodePsbt(psbt: string, type = "hex") {
   try {
     if (type === "base64") {

package/src/evm/service.ts

@@ -4,12 +4,15 @@ import {
   createPublicClient,
   formatUnits,
   fromHex,
+  hexToBigInt,
   http,
   isHex,
+  numberToHex,
   parseTransaction,
   parseUnits,
   toHex,
   Transaction,
+  isAddressEqual,
 } from "viem";
 
 import { BaseService } from "../base/service";
@@ -20,7 +23,7 @@ import {
   ITypedData,
   INetwork,
   TomoAppInfo,
-  IaccountInfo,
+  IAccountInfo,
   TransactionParams,
   QueryGasResponse,
 } from "../types";
@@ -30,12 +33,12 @@ export class EvmService extends BaseService {
   private static instance: EvmService;
   public chainType: ChainTypes | "";
 
-  public constructor(chainType: ChainTypes, accountInfo: IaccountInfo, tomoAppInfo: TomoAppInfo) {
+  public constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
     super(tomoAppInfo, accountInfo);
     this.chainType = chainType;
   }
 
-  public static getInstance(chainType: ChainTypes, accountInfo: any, tomoAppInfo: TomoAppInfo) {
+  public static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
     if (!EvmService.instance) {
       EvmService.instance = new EvmService(chainType, accountInfo, tomoAppInfo);
     }
@@ -96,26 +99,26 @@ export class EvmService extends BaseService {
 
   public async personal_sign([message, address]: [`0x${string}`, `0x${string}`]): Promise<`0x${string}`> {
     const accounts = await this.accountInfo.getCurrent();
-    if (accounts[0].address !== address) {
+    if (!isAddressEqual(accounts[0].address, address)) {
       throw new Error("address is not the current account");
     }
     const signature = await this.accountInfo.signMessage(message);
-    return signature;
+    return signature as `0x${string}`;
   }
 
   public async eth_signTypedData_v4([address, typedData]: [`0x${string}`, ITypedData]): Promise<`0x${string}`> {
     const accounts = await this.accountInfo.getCurrent();
-    if (accounts[0].address !== address) {
+    if (!isAddressEqual(accounts[0].address, address)) {
       throw new Error("address is not the current account");
     }
     const signature = await this.accountInfo.signTypedData(typedData);
 
-    return signature;
+    return signature as `0x${string}`;
   }
 
   public async eth_getBalance([address, type]: [`0x${string}`, "latest"]): Promise<string> {
     const accounts = await this.accountInfo.getCurrent();
-    if (accounts[0].address !== address) {
+    if (!isAddressEqual(accounts[0].address, address)) {
       throw new Error("address is not the current account");
     }
     if (type !== "latest") {
@@ -200,58 +203,6 @@ export class EvmService extends BaseService {
     };
   }
 
-  public async eth_estimateGas(txs: Transaction[]): Promise<`0x${string}`> {
-    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: QueryGasParams = {
-      chainIndex: Number(chainId),
-      callData: "0x",
-      gasLimitParam: {
-        from,
-        to,
-        value: value as `0x${string}`,
-      },
-      addressList: [from],
-    };
-
-    const chainType = this.chainType as ChainTypes;
-    const {
-      data: gasInfo,
-      success,
-      message,
-    }: any = await this.transactions.queryGasInfo({
-      chainType,
-      params: queryGasParams,
-    });
-    if (!success) {
-      console.error("queryGasInfo evm", txs, message, gasInfo);
-
-      const { gasFee } = SupportedChainTypes[chainType];
-      return gasFee.toString() as `0x${string}`;
-    }
-
-    const res = getAllTypeChainIds({ chainId, chainType });
-    const { nativeCurrencyDecimals }: any = await this.networks.getNetworkByChainId(res.chainId as string);
-
-    const { baseFee = 1, gasLimit = 0 } = gasInfo;
-
-    const baseFeeBN = new BigNumber(baseFee);
-    const calcFee = (feeLevel: "priorityFeeLow" | "priorityFeeMedium" | "priorityFeeHigh") => {
-      const fee = baseFeeBN.plus(gasInfo[feeLevel] || 0);
-      const gasFee = fee.times(gasLimit);
-      return toHex(BigInt(gasFee.toNumber()), nativeCurrencyDecimals);
-    };
-    return calcFee("priorityFeeMedium");
-  }
-
   private async createPublicClient({ chainId, rpcUrl }: { chainId?: string; rpcUrl?: string }): Promise<any> {
     if (rpcUrl) {
       return createPublicClient({
@@ -274,6 +225,30 @@ export class EvmService extends BaseService {
     });
   }
 
+  public async eth_estimateGas(txs: Transaction[]): Promise<`0x${string}`> {
+    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 as `0x${string}`) });
+      return gas;
+    } catch (error) {
+      console.warn("Failed to estimate gas:", error);
+      // throw new Error(`Failed to estimate gas: ${error}`);
+
+      const BaseConfig = SupportedChainTypes[ChainTypes.EVM];
+      const { gasFee } = BaseConfig;
+      return numberToHex(parseUnits(gasFee.toString(), 18));
+    }
+  }
+
   // Get nonce for current account
   public async eth_getTransactionCount([address, type]: [`0x${string}`, "latest" | "pending"]): Promise<number> {
     const accounts = await this.accountInfo.getCurrent();
@@ -297,14 +272,16 @@ export class EvmService extends BaseService {
   //https://docs.metamask.io/snaps/reference/keyring-api/chain-methods/#eth_signtransaction
   public async eth_signTransaction(
     txParams: {
-      type?: number;
+      type?: "eip1559" | "legacy";
       from: `0x${string}`;
       to: `0x${string}`;
       value: `0x${string}`;
       data?: `0x${string}`;
       chainId: `0x${string}`;
       nonce: `0x${string}`;
-      gasLimit: `0x${string}`;
+      gasLimit?: `0x${string}`;
+      gas?: `0x${string}`;
+      gasPrice?: `0x${string}`;
       maxFeePerGas?: `0x${string}`;
       maxPriorityFeePerGas?: `0x${string}`;
       accessList?: any[];
@@ -318,32 +295,39 @@ export class EvmService extends BaseService {
       nonce: "number",
       maxPriorityFeePerGas: "bigint",
       maxFeePerGas: "bigint",
-      gasLimit: "bigint",
+      gasPrice: "bigint",
       gas: "bigint",
     };
-    let txData: any = txParams?.[0];
-    const gas = txData?.gas || txData?.gasLimit;
-    txData = { ...txData, gas, gasLimit: gas };
+    const txData: any = txParams?.[0];
+    txData.gas = txData?.gas || txData?.gasLimit;
     txData.data = txData.data || "0x";
+    txData.value = txData.value || "0x";
+    txData.nonce = txData.nonce || "0x0";
+
+    if (!txData?.gas || !txData?.to || !txData?.chainId) {
+      throw new Error("gas or to or chainId is not set");
+    }
 
     const accounts = await this.accountInfo.getCurrent();
     const address = accounts[0].address;
-    if (txData?.from && txData?.from !== address) {
+    if (txData?.from && !isAddressEqual(txData?.from, address)) {
       console.error("eth_signTransaction error data: from is not the current account", txData);
       throw new Error(`eth_signTransaction error data: from is not the current account`);
     }
     delete txData?.from;
+    delete txData?.gasLimit;
 
     const preparedTx: any = {
-      type: "eip1559",
-      gas: txData?.gasLimit,
-      account: address,
+      gas: txData?.gas,
     };
     for (const key in preparedTxPropsType) {
-      if (!txData?.[key] || !isHex(txData?.[key])) {
-        throw new Error(`${key}: no data or wrong type`);
+      if (txData?.[key] && isHex(txData?.[key])) {
+        preparedTx[key] = preparedTxPropsType[key] === "number" ? fromHex(txData[key], "number") : txData[key];
       }
-      preparedTx[key] = preparedTxPropsType[key] === "number" ? fromHex(txData[key], "number") : txData[key];
+    }
+
+    if (txData?.type !== "legacy") {
+      delete preparedTx.gasPrice;
     }
 
     try {

package/src/index.ts

@@ -1,14 +1,14 @@
 import { EvmService } from "./evm/service";
 import { SolanaService } from "./solana/service";
-// import { DogecoinService } from "./dogecoin/service";
+import { DogecoinService } from "./dogecoin/service";
 import { ChainTypes } from "@tomo-inc/wallet-utils";
 
-export { EvmService, SolanaService };
+export { EvmService, SolanaService, DogecoinService };
 
 export const ChainTypeServices = {
   [ChainTypes.EVM]: EvmService,
   [ChainTypes.SOL]: SolanaService,
-  // [ChainTypes.DOGE]: DogecoinService,
+  [ChainTypes.DOGE]: DogecoinService,
 };
 
 export { TomoWallet } from "./wallet";
@@ -18,11 +18,12 @@ export { TomoWallet } from "./wallet";
 
 export type {
   ChainAddress,
+  IAccountInfo,
   IAccount,
   TomoAppInfo,
   TransactionItem,
   TransactionsParams,
-  TransactionsResponse
+  TransactionsResponse,
 } from "./types";
 
 export { AccountType, TxTypes } from "./types";