@tomo-inc/chains-service 0.0.2

package/src/dogecoin/utils.ts

@@ -0,0 +1,601 @@
+import { cache } from "@tomo-inc/wallet-utils";
+import { BigNumber } from "bignumber.js";
+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 { DogeSpendableUtxos } from "./type";
+
+import * as base from "./base";
+
+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);
+    if (amount.isNaN() || amount.isNegative()) {
+      throw new Error("Invalid amount");
+    }
+    return amount.times(KOINU_PER_DOGE).integerValue(BigNumber.ROUND_DOWN).toNumber();
+  } catch (error: any) {
+    throw new Error(`toSatoshi failed: ${error.message}`);
+  }
+}
+
+export function toBitcoin(satoshis: number | string): number {
+  try {
+    const amount = new BigNumber(satoshis);
+    if (amount.isNaN() || amount.isNegative()) {
+      throw new Error("Invalid Koinu amount");
+    }
+    return amount.dividedBy(KOINU_PER_DOGE).toNumber();
+  } catch (error: any) {
+    throw new Error(`toBitcoin failed: ${error.message}`);
+  }
+}
+
+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) {
+    usedUtxos[txid] = 1;
+  }
+  cache.set("UsedUtxos", usedUtxos, false);
+}
+
+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,
+  amount,
+  fee,
+  spendableUtxos,
+}: {
+  from: string;
+  to: string;
+  amount: number;
+  fee: number;
+  spendableUtxos: DogeSpendableUtxos[];
+}) {
+  let utxos = spendableUtxos;
+  if (!utxos || utxos.length === 0) {
+    utxos = await API.getSpendableUtxos(from);
+  }
+
+  const sendAmount = toSatoshi(amount);
+  const sendCost = toSatoshi(fee);
+  const totalNeeded = sendAmount + sendCost;
+
+  const sortedUtxos = utxos.sort((a, b) => b.outputValue - a.outputValue);
+
+  // First pass: collect sufficient UTXOs to cover the amount + fee
+  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");
+  }
+
+  // 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 inputs = [];
+  const usingUtxos: any = {};
+  let addedAmount = 0;
+
+  for (const { utxo, utxoDetail } of utxoResults) {
+    if (addedAmount >= totalNeeded) break;
+
+    const { txid, vout, outputValue, address = from }: any = utxo;
+
+    if (utxoDetail?.hex && !usingUtxos[txid]) {
+      inputs.push({
+        txId: txid,
+        vOut: vout,
+        amount: Number(outputValue),
+        nonWitnessUtxo: utxoDetail.hex,
+        address,
+      });
+      usingUtxos[txid] = 1;
+      addedAmount += Number(outputValue);
+    }
+  }
+
+  if (addedAmount < totalNeeded) {
+    throw new Error("not enough funds to cover amount and fee");
+  }
+
+  const outputs = [
+    {
+      address: to,
+      amount: sendAmount,
+    },
+  ];
+
+  const changeAmount = addedAmount - sendAmount - sendCost;
+  if (changeAmount > 0) {
+    outputs.push({
+      address: from,
+      amount: changeAmount,
+    });
+  }
+
+  const params = {
+    address: from,
+    inputs,
+    outputs,
+  };
+
+  const psbtBase64 = DogecoinUtils.buildPsbtToBase64(params as any);
+  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") {
+      // Convert from base64 to hex
+      const psbtHex = base.toHex(base.fromBase64(psbt));
+      return Psbt.fromHex(psbtHex, {
+        network,
+      });
+    }
+
+    return Psbt.fromHex(psbt, {
+      network,
+    });
+  } catch (error) {
+    console.error("Failed to decode PSBT:", error);
+    throw error;
+  }
+}
+
+export class TransactionParser {
+  public rawTx: string;
+
+  constructor(rawTx: string) {
+    this.rawTx = rawTx;
+  }
+
+  hexToText(hex: string) {
+    let str = "";
+    for (let i = 0; i < hex.length; i += 2) {
+      str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+    }
+    return str;
+  }
+
+  extractOPReturnData() {
+    const ordIndex = this.rawTx.indexOf("6f7264"); // 'ord' in hex
+    if (ordIndex === -1) return null;
+
+    const dataHex = this.rawTx.substring(ordIndex);
+    const dataText = this.hexToText(dataHex);
+
+    // Extract JSON data
+    const jsonMatch = dataText.match(/\{.*?\}/);
+    return jsonMatch ? JSON.parse(jsonMatch[0]) : null;
+  }
+
+  parseScript() {
+    return {
+      version: this.rawTx.substring(0, 8),
+      inputCount: parseInt(this.rawTx.substring(8, 10)),
+      inputs: this.parseInputs(),
+      opReturnData: this.extractOPReturnData(),
+    };
+  }
+
+  parseInputs() {
+    const inputs = [];
+    const position = 10; // After version and input count
+
+    // Parse first input
+    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;
+  }
+}

package/src/evm/rpc.ts

@@ -0,0 +1,68 @@
+import { createPublicClient, http, parseUnits } from "viem";
+import { getContract, erc20Abi, encodeFunctionData, decodeFunctionData } from "viem";
+
+export function getRPCClient(network: any) {
+  const { chainId, name, rpcUrls, nativeCurrencyDecimals, nativeCurrencyName, nativeCurrencySymbol } = network;
+
+  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: 10_000,
+    cacheTime: 10_000,
+    transport: http(),
+  });
+
+  return { rpcClient };
+}
+
+export function getERC20Contract(client: any, address: `0x${string}`) {
+  return getContract({
+    address,
+    abi: erc20Abi,
+    client,
+  });
+}
+
+export function decodeErc20Func(data: `0x${string}`) {
+  return decodeFunctionData({ data, abi: erc20Abi });
+}
+
+export function createErc20TxData(params: any, token: any) {
+  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 },
+  };
+}