@tomo-inc/chains-service 0.0.7 → 0.0.9

package/src/dogecoin/service.ts

@@ -6,37 +6,44 @@ 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 { IAccountInfo, QueryGasParams, QueryGasResponse, TomoAppInfo } from "../types";
+import { TransactionParams } from "./type";
 
 import * as API from "./rpc";
 import * as utils from "./utils";
-import { DogeTxData, waitOnly } from "./utils";
+import { DogeTxData } from "./type";
 
 import { BaseConfig } from "./config";
+import { createPsbt, addUsedUtxos } from "./utils";
 
 export class DogecoinService extends BaseService {
   private static instance: DogecoinService;
   public chainType: ChainTypes | "";
+  public rpcService: typeof API;
 
-  public constructor(chainType: ChainTypes, accountInfo: IaccountInfo, tomoAppInfo: TomoAppInfo) {
+  public constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
     super(tomoAppInfo, accountInfo);
     this.chainType = chainType;
+    this.rpcService = API;
   }
 
   //singleton
-  public static getInstance(chainType: ChainTypes, accountInfo: any, tomoAppInfo: TomoAppInfo) {
+  public static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, 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);
+    const addresses = await this.accountInfo.getCurrent();
+    const { publicKey, address } = addresses?.[0] || {};
+    if (!address) {
+      throw new Error("address is not set");
+    }
+    const { balance = 0 } = await API.getBalance(address);
 
     return {
-      address: currentAddress,
+      address,
       balance,
       approved: true,
       publicKey,
@@ -44,21 +51,29 @@ export class DogecoinService extends BaseService {
   }
 
   public async getAccounts(): Promise<string[]> {
-    const { addresses = [] }: any = await this.accountInfo.getIds();
-    return addresses;
+    const accounts = await this.accountInfo.getCurrent();
+    return accounts.map((account: { address: string }) => account.address);
   }
 
   public async getConnectionStatus(): Promise<{ connected: boolean; address: string; selectedWalletAddress: string }> {
-    const { currentAddress }: any = await this.accountInfo.getIds();
+    const addresses = await this.accountInfo.getCurrent();
+    const { address } = addresses?.[0] || {};
+    if (!address) {
+      throw new Error("address is not set");
+    }
     return {
       connected: true,
-      address: currentAddress,
-      selectedWalletAddress: currentAddress,
+      address,
+      selectedWalletAddress: address,
     };
   }
 
   public async getBalance(): Promise<{ address: string; balance: number }> {
-    const { currentAddress: address }: any = await this.accountInfo.getIds();
+    const addresses = await this.accountInfo.getCurrent();
+    const { address } = addresses?.[0] || {};
+    if (!address) {
+      throw new Error("address is not set");
+    }
 
     const { balance = 0 } = await API.getBalance(address);
 
@@ -68,12 +83,12 @@ export class DogecoinService extends BaseService {
     };
   }
 
-  public async signMessage({ text, type }: { text: string; type?: string }): Promise<{ signedMessage: string }> {
-    if (type !== "") {
+  public async signMessage({ message, type }: { message: string; type?: string }): Promise<{ signedMessage: string }> {
+    if (type) {
       throw new Error("bip322simple not support.");
     }
 
-    const signature = await this.accountInfo.signMessage(text);
+    const signature = await this.accountInfo.signMessage(message);
 
     return {
       signedMessage: signature,
@@ -81,31 +96,18 @@ export class DogecoinService extends BaseService {
   }
 
   public async requestSignedMessage({
-    text,
+    message,
     type,
   }: {
-    text: string;
+    message: string;
     type?: string;
   }): Promise<{ signedMessage: string }> {
     return await this.signMessage({
-      text,
+      message,
       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 = {
@@ -114,7 +116,7 @@ export class DogecoinService extends BaseService {
       value: toHex(parseUnits(amount.toString(), decimals)),
     };
     const queryGasParams: QueryGasParams = {
-      chainIndex: Number(chainId),
+      chainIndex: Number(chainId || BaseConfig.chainId),
       callData: "0x",
       gasLimitParam,
       addressList: [txData.from],
@@ -164,19 +166,14 @@ export class DogecoinService extends BaseService {
     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));
+    const psbtBase64 = await DogecoinUtils.rawTxToPsbtBase64(rawTx);
+    const signedPsbt = await this.accountInfo.signTransaction(JSON.stringify({ psbtBase64 }));
 
-    if (!signedRawTx) {
+    if (!signedPsbt) {
       return null;
     }
 
+    const signedRawTx = DogecoinUtils.extractPsbtTransaction(signedPsbt, 100000);
     if (signOnly) {
       return {
         signedRawTx,
@@ -200,18 +197,16 @@ export class DogecoinService extends BaseService {
       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);
+    const { psbtBase64, usingUtxos } = await createPsbt(txData as any);
+    const signedPsbt = await this.accountInfo.signTransaction(JSON.stringify({ psbtBase64 }));
+    const signedTx = DogecoinUtils.extractPsbtTransaction(signedPsbt, 100000);
 
     if (signedTx === "") {
       throw new Error("Error: sign transaction err.");
     }
     try {
       const { txid } = await API.sendDogeTx(signedTx);
-      utils.addUsedUtxos(_UsingUtxos);
+      addUsedUtxos(usingUtxos);
       return { txId: txid };
     } catch (err) {
       throw new Error("Error: send transaction err." + JSON.stringify(err));
@@ -233,219 +228,4 @@ export class DogecoinService extends BaseService {
       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

@@ -27,3 +27,15 @@ export interface TransactionParams {
   chainId?: number | string;
   tokenAddress?: string;
 }
+
+export interface DogeTxData {
+  amountMismatch?: boolean;
+  amount: number;
+  fee: number;
+  to: string;
+  from: string;
+  senderAddress?: string;
+  sender?: string;
+  fromAddress?: string;
+  spendableUtxos?: DogeSpendableUtxos[];
+}

package/src/dogecoin/utils-doge.ts

@@ -1,6 +1,7 @@
-import { address as AddressLib, Psbt } from "bitcoinjs-lib";
+import { address as AddressLib, Psbt, Transaction } from "bitcoinjs-lib";
 import * as base from "./base";
 import { network } from "./config";
+import * as APIs from "./rpc";
 
 /**
  * UTXO Transaction type definition
@@ -67,8 +68,8 @@ export class DogecoinUtils {
     // Add outputs
     for (const output of tx.outputs) {
       psbt.addOutput({
+        value: BigInt(output?.amount || 0),
         address: output.address,
-        value: BigInt(output.amount),
       });
     }
 
@@ -94,6 +95,9 @@ export class DogecoinUtils {
       network,
     });
 
+    const maximumFeeRate = _maximumFeeRate || 100000;
+    psbt.setMaximumFeeRate(maximumFeeRate);
+
     // Note: Fee rate check may be inaccurate when extracting transaction
     // For strict fee rate checking, it should be calculated manually after extracting the transaction
 
@@ -102,4 +106,86 @@ export class DogecoinUtils {
     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: string): Promise<string> {
+    try {
+      // Clean the hex string (remove 0x prefix if present)
+      const cleanHex = rawTx.startsWith("0x") ? rawTx.slice(2) : rawTx;
+
+      // Parse the raw transaction
+      const transaction = Transaction.fromHex(cleanHex);
+
+      // Create a new PSBT
+      const psbt = new Psbt({ network });
+
+      // Add inputs from the transaction
+      // Each input references a previous transaction's output
+      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;
+
+        // Add input without nonWitnessUtxo initially
+        // The nonWitnessUtxo (full previous transaction) should be added separately
+        // if needed for signing. For now, we create the PSBT structure.
+        const inputOptions: any = {
+          hash,
+          index,
+        };
+
+        try {
+          const prevTxDetail = await APIs.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)}`,
+          );
+        }
+
+        // If the transaction is unsigned and we have the script, we can add it
+        // Otherwise, nonWitnessUtxo will need to be fetched from RPC
+        psbt.addInput(inputOptions);
+      }
+
+      // Add outputs from the transaction
+      for (const output of transaction.outs) {
+        // Extract address and value from the output script
+        try {
+          const address = AddressLib.fromOutputScript(output.script, network);
+          psbt.addOutput({
+            address,
+            value: BigInt(output?.value || 0),
+          });
+        } catch (error) {
+          // If address extraction fails (e.g., OP_RETURN), add output with script and value
+          psbt.addOutput({
+            script: output.script,
+            value: BigInt(output?.value || 0),
+          });
+        }
+      }
+
+      // Convert PSBT to base64
+      const psbtHex = psbt.toHex();
+      return base.toBase64(base.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)}`,
+      );
+    }
+  }
 }