@tomo-inc/chains-service 0.0.2

package/src/dogecoin/service.ts

@@ -0,0 +1,451 @@
+import { ChainTypes } from "@tomo-inc/wallet-utils";
+
+import { BaseService } from "../base/service";
+
+import { BigNumber } from "bignumber.js";
+import { DogecoinUtils } from "./utils-doge";
+import { parseUnits, toHex } from "viem";
+
+import { IaccountInfo, QueryGasParams, QueryGasResponse, TomoAppInfo } from "../types";
+import { TransactionParams, DunesTransactionParams } from "./type";
+
+import * as API from "./rpc";
+import * as utils from "./utils";
+import { DogeTxData, waitOnly } from "./utils";
+
+import { BaseConfig } from "./config";
+
+export class DogecoinService extends BaseService {
+  private static instance: DogecoinService;
+  public chainType: ChainTypes | "";
+
+  public constructor(chainType: ChainTypes, accountInfo: IaccountInfo, tomoAppInfo: TomoAppInfo) {
+    super(tomoAppInfo, accountInfo);
+    this.chainType = chainType;
+  }
+
+  //singleton
+  public static getInstance(chainType: ChainTypes, accountInfo: any, tomoAppInfo: TomoAppInfo) {
+    if (!DogecoinService.instance) {
+      DogecoinService.instance = new DogecoinService(chainType, accountInfo, tomoAppInfo);
+    }
+    return DogecoinService.instance;
+  }
+  public async requestAccounts(): Promise<{ address: string; balance: number; approved: boolean; publicKey: string }> {
+    const { currentAddress, publicKey = "" }: any = await this.accountInfo.getIds();
+    const { balance = 0 } = await API.getBalance(currentAddress);
+
+    return {
+      address: currentAddress,
+      balance,
+      approved: true,
+      publicKey,
+    };
+  }
+
+  public async getAccounts(): Promise<string[]> {
+    const { addresses = [] }: any = await this.accountInfo.getIds();
+    return addresses;
+  }
+
+  public async getConnectionStatus(): Promise<{ connected: boolean; address: string; selectedWalletAddress: string }> {
+    const { currentAddress }: any = await this.accountInfo.getIds();
+    return {
+      connected: true,
+      address: currentAddress,
+      selectedWalletAddress: currentAddress,
+    };
+  }
+
+  public async getBalance(): Promise<{ address: string; balance: number }> {
+    const { currentAddress: address }: any = await this.accountInfo.getIds();
+
+    const { balance = 0 } = await API.getBalance(address);
+
+    return {
+      address,
+      balance,
+    };
+  }
+
+  public async signMessage({ text, type }: { text: string; type?: string }): Promise<{ signedMessage: string }> {
+    if (type !== "") {
+      throw new Error("bip322simple not support.");
+    }
+
+    const signature = await this.accountInfo.signMessage(text);
+
+    return {
+      signedMessage: signature,
+    };
+  }
+
+  public async requestSignedMessage({
+    text,
+    type,
+  }: {
+    text: string;
+    type?: string;
+  }): Promise<{ signedMessage: string }> {
+    return await this.signMessage({
+      text,
+      type,
+    });
+  }
+
+  public async requestDecryptedMessage({ message }: { message: string }): Promise<{ decryptedMessage: string }> {
+    try {
+      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));
+    }
+  }
+
+  public async _queryGasInfo(txData: TransactionParams): Promise<QueryGasResponse> {
+    const { chainId, amount = 0, decimals = 8 } = txData;
+    const gasLimitParam: any = {
+      from: txData.from,
+      to: txData.to,
+      value: toHex(parseUnits(amount.toString(), decimals)),
+    };
+    const queryGasParams: QueryGasParams = {
+      chainIndex: Number(chainId),
+      callData: "0x",
+      gasLimitParam,
+      addressList: [txData.from],
+    };
+
+    const {
+      data: gasInfo,
+      success,
+      message,
+    }: any = 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: string) => {
+      const gasFee = new BigNumber(gasInfo[feeLevel] || baseFee).times(gasLimit);
+      return utils.toBitcoin(gasFee.toNumber());
+    };
+
+    const fees = {
+      low: calcFee("priorityFeeLow"),
+      medium: calcFee("priorityFeeMedium"),
+      high: calcFee("priorityFeeHigh"),
+    };
+
+    return {
+      success: true,
+      fees,
+      gasFee: fees.high,
+    };
+  }
+
+  public async requestPsbt({
+    rawTx,
+    signOnly,
+  }: {
+    rawTx: string;
+    signOnly?: boolean;
+  }): Promise<{ signedRawTx: string; txId?: string } | null> {
+    const params = {
+      type: "signRawTx",
+      data: {
+        walletId: -1,
+        rawTx,
+      },
+    };
+    const signedRawTx = await this.accountInfo.signTransaction(JSON.stringify(params));
+
+    if (!signedRawTx) {
+      return null;
+    }
+
+    if (signOnly) {
+      return {
+        signedRawTx,
+      };
+    }
+
+    const { txid = "" } = await API.sendDogeTx(signedRawTx);
+    return {
+      txId: txid,
+      signedRawTx,
+    };
+  }
+
+  public async requestTransaction(txData: DogeTxData): Promise<{ txId: string } | null> {
+    //txData = createTx;
+    const spendableUtxos = txData?.spendableUtxos;
+    if (txData.amountMismatch) {
+      throw new Error("balance_insufficient");
+    }
+    if (!spendableUtxos || spendableUtxos?.length === 0) {
+      txData.spendableUtxos = await API.getSpendableUtxos(txData.from);
+    }
+
+    let signedTx = "";
+    const _UsingUtxos = {};
+    const dogeTxParams = await utils.createPsbt(txData as any);
+    const signedPsbt = await this.accountInfo.signTransaction(JSON.stringify(dogeTxParams));
+    signedTx = DogecoinUtils.extractPsbtTransaction(signedPsbt, 100000);
+
+    if (signedTx === "") {
+      throw new Error("Error: sign transaction err.");
+    }
+    try {
+      const { txid } = await API.sendDogeTx(signedTx);
+      utils.addUsedUtxos(_UsingUtxos);
+      return { txId: txid };
+    } catch (err) {
+      throw new Error("Error: send transaction err." + JSON.stringify(err));
+    }
+  }
+
+  public async getTransactionStatus({ txId }: { txId: string }): Promise<any> {
+    const transaction = await API.getTxDetail(txId);
+    if (!transaction?.txid) {
+      return null as any;
+    }
+
+    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],
+    };
+  }
+
+  public async getDRC20Balance(params: {
+    ticker: string;
+  }): Promise<{ availableBalance: number; transferableBalance: number; ticker: string; address: string }> {
+    const { currentAddress: address }: any = await this.accountInfo.getIds();
+    const { ticker } = params;
+
+    const { balances = [] } = await API.getDRC20Balance(address, ticker);
+
+    let availableBalance = 0;
+    let transferableBalance = 0;
+    if (balances.length) {
+      availableBalance = balances[0].availableBalance;
+      transferableBalance = balances[0].transferableBalance;
+    }
+
+    return {
+      availableBalance,
+      transferableBalance,
+      ticker,
+      address,
+    };
+  }
+
+  public async getTransferableDRC20(params: {
+    ticker: string;
+  }): Promise<{ inscriptions: any[]; ticker: string; address: string }> {
+    const { currentAddress: address }: any = await this.accountInfo.getIds();
+    const { ticker } = params;
+
+    const query = await API.getDRC20Inscriptions(address, ticker);
+
+    return {
+      inscriptions: query.list || [],
+      ticker: ticker,
+      address: address,
+    };
+  }
+
+  public async requestAvailableDRC20Transaction({
+    ticker,
+    amount,
+  }: {
+    ticker: string;
+    amount: number;
+  }): Promise<{ txId: string; ticker: string; amount: number }> {
+    const inscription = `{"p":"drc-20","op":"transfer","tick":"${ticker}","amt":"${amount}"}`;
+    let params = null;
+    let usingUtxos = null;
+
+    try {
+      const { currentAddress: senderAddress }: any = await this.accountInfo.getIds();
+      const utxos = await API.getSpendableUtxos(senderAddress);
+      const res = utils.createDrc20Data(utxos, senderAddress, inscription);
+      params = res.params;
+      usingUtxos = res.usingUtxos || {};
+    } catch (err) {
+      throw new Error("Error: sign transaction err." + JSON.stringify(err));
+    }
+
+    const signedTxs = await this.accountInfo.signTransaction(params);
+    const { commitTx = "", revealTxs = [] } = signedTxs;
+    const revealTx = revealTxs[0] || "";
+    if (commitTx === "" || revealTx === "") {
+      throw new Error("Error: sign transaction err.");
+    }
+    const { txid: commitTxId } = await API.sendDogeTx(commitTx);
+    await waitOnly(0.3 * 1000); //ms
+    const { txid: revealTxId } = await API.sendDogeTx(revealTx);
+    if (revealTxId && commitTxId) {
+      utils.addUsedUtxos(usingUtxos);
+    }
+
+    return {
+      txId: revealTxId,
+      ticker,
+      amount,
+    };
+  }
+
+  public async getInscriptionTransactionDetail(params: { recipientAddress: string; location: string }): Promise<{
+    senderAddress: string;
+    inscription: any;
+    inputTxid: string;
+    fee: number;
+    amount: number;
+    rawTx: string;
+  } | null> {
+    const { currentAddress: senderAddress }: any = await this.accountInfo.getIds();
+    const { recipientAddress, location } = params;
+
+    const locations: string[] = location.split(":");
+    const inputTxid: string = locations[0] || "";
+    const vout = Number(locations[1] || 0);
+    const offset = Number(locations[2] || 0);
+
+    if (inputTxid?.length !== 64 || Number.isNaN(vout)) {
+      return null;
+    }
+
+    const res = await API.getInscriptionsUtxo(senderAddress, {
+      txid: inputTxid,
+      vout,
+    });
+    const { inscriptions = [] } = res || {};
+
+    if (inscriptions.length === 0) {
+      return null;
+    }
+
+    const inscription = inscriptions?.find((i: any) => i.offset === offset);
+    const { rawTx, fee, amount }: any = await API.createNFTTransaction({
+      senderAddress,
+      recipientAddress,
+      location,
+      inscriptionId: inscription.inscription_id,
+    });
+
+    return {
+      senderAddress,
+      inscription,
+      inputTxid,
+      fee,
+      amount,
+      rawTx,
+    };
+  }
+
+  public async requestInscriptionTransaction(params: {
+    recipientAddress: string;
+    location: string;
+  }): Promise<{ txId: string }> {
+    const { currentAddress: senderAddress }: any = await this.accountInfo.getIds();
+    const { recipientAddress, location } = params;
+
+    const locations: string[] = location.split(":");
+    const inputTxid: string = locations[0] || "";
+
+    const detail = await this.getInscriptionTransactionDetail(params);
+    if (!detail) {
+      throw new Error("Error: location not found");
+    }
+
+    const { fee, amount }: any = detail || {};
+
+    const utxos = await API.getSpendableUtxos(senderAddress);
+    const { psbtBase64, usingUtxos } = await utils.createInscriptionPsbt({
+      inscriptionId: inputTxid,
+      senderAddress,
+      recipientAddress,
+      utxos,
+      fee,
+      amount,
+    });
+
+    const signedRawTx = await this.accountInfo.signTransaction({
+      type: 2,
+      psbt: psbtBase64,
+    });
+    const tx = DogecoinUtils.extractPsbtTransaction(signedRawTx, 100000);
+
+    const { txid } = await API.sendDogeTx(tx);
+
+    if (txid) {
+      utils.addUsedUtxos(usingUtxos);
+    }
+
+    return {
+      txId: txid,
+    };
+  }
+
+  public async getDunesBalance(params?: {
+    ticker: string;
+  }): Promise<{ balance: number; ticker: string; address: string }> {
+    const { ticker = "" } = params || {};
+
+    if (!ticker) {
+      throw new Error("Error: ticker is required");
+    }
+
+    const { currentAddress: address }: any = await this.accountInfo.getIds();
+    const { balances = [] } = await API.getDunesBalance(address, ticker);
+
+    let balance = 0;
+    if (balances.length) {
+      balance = balances[0].overallBalance;
+    }
+    return {
+      balance,
+      ticker,
+      address,
+    };
+  }
+
+  public async requestDunesTransaction(params: DunesTransactionParams): Promise<{ txId: string }> {
+    const { currentAddress: senderAddress }: any = await this.accountInfo.getIds();
+    const { rawTx: rawTransaction, inputs }: any = await API.createDunesTransaction({ ...params, senderAddress });
+
+    //utxo
+
+    const signParams = {
+      rawTransaction,
+    };
+    const signedRawTx = await this.accountInfo.signTransaction(signParams);
+
+    if (!signedRawTx) {
+      throw new Error("Error: sign transaction err.");
+    }
+
+    const { txid = "" } = await API.sendDogeTx(signedRawTx);
+    return {
+      txId: txid,
+    };
+  }
+}

package/src/dogecoin/type.ts

@@ -0,0 +1,29 @@
+export interface DunesTransactionParams {
+  senderAddress?: string;
+  recipientAddress: string;
+  amount: number;
+  ticker: string;
+  duneId?: string;
+}
+
+export type DogeSpendableUtxos = {
+  txid: string;
+  vout: number;
+  outputValue: number;
+  script: string;
+  tx?: {
+    txid: string;
+    vout: number;
+  };
+};
+
+export interface TransactionParams {
+  accountId?: string;
+  from: string;
+  to: string;
+  fee?: string;
+  amount: number;
+  decimals?: number;
+  chainId?: number | string;
+  tokenAddress?: string;
+}

package/src/dogecoin/utils-doge.ts

@@ -0,0 +1,105 @@
+import { address as AddressLib, Psbt } from "bitcoinjs-lib";
+import * as base from "./base";
+import { network } from "./config";
+
+/**
+ * UTXO Transaction type definition
+ * Replaces the utxoTx type from @okxweb3/coin-bitcoin
+ */
+export interface utxoTx {
+  address: string;
+  inputs: Array<{
+    txId: string;
+    vOut: number;
+    amount: number;
+    nonWitnessUtxo?: string; // hex string
+    address?: string;
+  }>;
+  outputs: Array<{
+    address: string;
+    amount: number;
+  }>;
+}
+
+export class DogecoinAddress {
+  static network = network;
+
+  static generatePath(addressIndex: number): string {
+    return `m/44'/3'/0'/0/${addressIndex || 0}`;
+  }
+
+  static verifyAddress(address: string): boolean {
+    try {
+      // Use bitcoinjs-lib address decoding
+      const decoded = AddressLib.fromBase58Check(address);
+      return decoded.version === network.pubKeyHash || decoded.version === network.scriptHash;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+export class DogecoinUtils {
+  /**
+   * Build the PSBT from the transaction
+   * @param tx utxoTx
+   * @param _maximumFeeRate number (optional, currently unused)
+   * @returns base64
+   */
+  static buildPsbtToBase64(tx: utxoTx, _maximumFeeRate?: number): string {
+    const psbt = new Psbt({ network: network });
+
+    // Add inputs
+    for (const input of tx.inputs) {
+      const inputOptions: any = {
+        hash: input.txId,
+        index: input.vOut,
+      };
+
+      // If nonWitnessUtxo (full transaction hex) exists, add it
+      if (input.nonWitnessUtxo) {
+        inputOptions.nonWitnessUtxo = Buffer.from(input.nonWitnessUtxo, "hex");
+      }
+
+      psbt.addInput(inputOptions);
+    }
+
+    // Add outputs
+    for (const output of tx.outputs) {
+      psbt.addOutput({
+        address: output.address,
+        value: BigInt(output.amount),
+      });
+    }
+
+    // Note: Fee rate check may be inaccurate at build stage since input values may not be fully determined
+    // For strict fee rate checking, it should be done after signing (extractPsbtTransaction)
+
+    // Convert to base64
+    const psbtHex = psbt.toHex();
+    return base.toBase64(base.fromHex(psbtHex));
+  }
+
+  /**
+   * Extract the transaction from the signed PSBT
+   * @param signedPsbt base64
+   * @param _maximumFeeRate number (optional, currently unused)
+   * @returns transaction hex
+   */
+  static extractPsbtTransaction(signedPsbt: string, _maximumFeeRate?: number): string {
+    const signedPsbtHex = base.toHex(base.fromBase64(signedPsbt));
+
+    // Create PSBT from hex
+    const psbt = Psbt.fromHex(signedPsbtHex, {
+      network,
+    });
+
+    // Note: Fee rate check may be inaccurate when extracting transaction
+    // For strict fee rate checking, it should be calculated manually after extracting the transaction
+
+    // Finalize all inputs and extract transaction
+    psbt.finalizeAllInputs();
+    const transaction = psbt.extractTransaction();
+    return transaction.toHex();
+  }
+}