@tomo-inc/chains-service 0.0.6 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomo-inc/chains-service",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "author": "tomo.inc",
   "license": "MIT",
   "private": false,
@@ -23,7 +23,7 @@
     "bitcoinjs-lib": "^7.0.0",
     "crypto-js": "4.2.0",
     "viem": "2.21.54",
-    "@tomo-inc/wallet-utils": "0.0.5"
+    "@tomo-inc/wallet-utils": "0.0.7"
   },
   "devDependencies": {
     "@types/supertest": "^2.0.12",

package/src/api/network-data.ts

@@ -30,12 +30,26 @@ export const loadNetworks = (WALLET_DOMAIN: string) => {
       supportHistory: false,
     },
     {
-      chainId: 221122420,
-      chainIndex: 22112242000,
-      name: "DOGEOS_DEVNET",
-      chainName: "DogeOS Devnet",
+      chainId: 26888,
+      chainIndex: 2688800,
+      name: "ABCORE_TESTNET",
+      chainName: "AB Core Testnet",
+      rpcUrls: ["https://rpc.core.testnet.ab.org"],
+      blockExplorerUrl: "https://explorer.core.testnet.ab.org",
+      platformType: "EVM",
+      isTestnet: true,
+      icon: "/assets/ab.svg",
+      supportSwap: true,
+      supportGift: false,
+      supportHistory: true,
+    },
+    {
+      chainId: 6281971,
+      chainIndex: 628197100,
+      name: "DOGEOS_TESTNET",
+      chainName: "DogeOS Testnet",
       rpcUrls: [`${WALLET_DOMAIN}/rpc/v1/doge_test`],
-      blockExplorerUrl: "https://blockscout.devnet.doge.xyz",
+      blockExplorerUrl: "https://rpc.testnet.dogeos.com",
       platformType: "EVM",
       isTestnet: true,
       icon: "/assets/dogeos.svg",

package/src/api/token.ts

@@ -43,11 +43,16 @@ export class TokenAPIs extends BasePublicService {
     }
   }
 
-  async getTokenRisk(params: { chainIndex: number; tokenAddress: string }): Promise<RemoteResponse<any>> {
-    if (typeof params.chainIndex !== "number" || !params.tokenAddress) {
+  async getTokenRisk(params: GetTokenInfoParams): Promise<RemoteResponse<any>> {
+    if (typeof params.chainIndex !== "number" || !params.address) {
       throw new Error("chainName or tokenAddress is required");
     }
-    const res = await this.tokenApi.post("/v1/market/risk/details", [params]);
+    const res = await this.tokenApi.post("/v1/market/risk/details", [
+      {
+        chainIndex: params.chainIndex,
+        tokenAddress: params.address,
+      },
+    ]);
     return {
       success: res?.data?.code === "0",
       message: res?.data?.msg,
@@ -142,13 +147,13 @@ export class TokenAPIs extends BasePublicService {
     }
   }
 
-  async getTokenDetail(params: { chainIndex: number; tokenAddress: string }): Promise<RemoteResponse<any>> {
+  async getTokenDetail(params: GetTokenInfoParams): Promise<RemoteResponse<any>> {
     //bad design, should: chainId + tokenAddress
-    const { chainIndex, tokenAddress } = params;
+    const { chainIndex, address } = params;
 
     const res = await this.tokenApi.get(`/v1/market/token/detail`, {
       params: {
-        tokenAddress,
+        tokenAddress: address,
         chainIndex,
       },
     });

package/src/base/service.ts

@@ -4,23 +4,23 @@ import { Transactions } from "./transaction";
 
 import { CONFIG } from "../config";
 import { tomoPublicApiService } from "../api";
-import { TomoAppInfo } from "../types";
+import { IAccountInfo, TomoAppInfo } from "../types";
 
 export class BaseService {
   public isDappConnected: boolean;
   public approveParams: any;
-  public accountInfo: any;
+  public accountInfo: IAccountInfo;
   public networks: Networks;
   public tokens: Tokens;
   public transactions: Transactions;
 
-  public constructor(tomoAppInfo: TomoAppInfo, accountInfo?: any) {
+  public constructor(tomoAppInfo: TomoAppInfo, accountInfo?: IAccountInfo) {
     if (!tomoAppInfo.tomoStage || !CONFIG[tomoAppInfo.tomoStage]) {
       throw new Error("Tomo stage is required");
     }
     const baseUrlConfig = CONFIG[tomoAppInfo.tomoStage];
     const { tokenAPIs, transactionAPIs, networkAPIs } = tomoPublicApiService(baseUrlConfig, tomoAppInfo);
-    this.accountInfo = accountInfo;
+    this.accountInfo = (accountInfo || null) as IAccountInfo;
     this.networks = new Networks(networkAPIs);
     this.tokens = new Tokens(tokenAPIs);
     this.transactions = new Transactions(transactionAPIs);

package/src/base/token.ts

@@ -1,6 +1,7 @@
 //types
 import { TokenInfo } from "../types";
 import { TokenAPIs } from "../api/token";
+import { GetTokenInfoParams } from "../api/types";
 
 export class Tokens {
   public tokenAPIs: TokenAPIs;
@@ -9,8 +10,8 @@ export class Tokens {
     this.tokenAPIs = tokenService;
   }
 
-  public async searchTokens({ chainIndex, query }: { chainIndex?: number; query?: string }): Promise<TokenInfo[]> {
-    const { data: tokens = [] }: any = await this.tokenAPIs.queryRemoteTokens({ keyword: query || "", chainIndex });
+  public async searchTokens({ chainIndex, keyword }: { chainIndex?: number; keyword: string }): Promise<TokenInfo[]> {
+    const { data: tokens = [] }: any = await this.tokenAPIs.queryRemoteTokens({ keyword, chainIndex });
     return tokens;
   }
 
@@ -19,19 +20,17 @@ export class Tokens {
   //   return tokenInfoData;
   // }
 
-  public async getTokenInfo({ address, chainIndex }: { address: string; chainIndex: number }): Promise<TokenInfo> {
-    const {
-      data: { data: tokenInfo },
-    }: any = await this.tokenAPIs.getTokenInfo({ address, chainIndex });
-    return tokenInfo;
+  public async getTokenInfo({ address, chainIndex }: GetTokenInfoParams): Promise<TokenInfo> {
+    const res: any = await this.tokenAPIs.getTokenInfo({ address, chainIndex });
+    return res?.data?.data;
   }
 
-  public async getTokenRiskInfo(_params: { chainIndex: number; tokenAddress: string }): Promise<any> {
+  public async getTokenRiskInfo(_params: GetTokenInfoParams): Promise<any> {
     const { data: tokenRiskInfo }: any = await this.tokenAPIs.getTokenRisk(_params);
     return tokenRiskInfo;
   }
 
-  public async getTokenDetail(_params: { chainName: string; chainIndex: number; tokenAddress: string }): Promise<any> {
+  public async getTokenDetail(_params: GetTokenInfoParams): Promise<any> {
     const { data }: any = await this.tokenAPIs.getTokenDetail(_params);
     return data;
   }

package/src/dogecoin/service.ts

@@ -6,37 +6,42 @@ 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 constructor(chainType: ChainTypes, accountInfo: IaccountInfo, tomoAppInfo: TomoAppInfo) {
+  public constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo) {
     super(tomoAppInfo, accountInfo);
     this.chainType = chainType;
   }
 
   //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 +49,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 +81,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,21 +94,24 @@ 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);
+      if (!this.accountInfo?.decryptedMessage) {
+        throw new Error("decryptedMessage is not supported");
+      }
+      const unsignRes = await this.accountInfo?.decryptedMessage(message);
       const { text = "" } = JSON.parse(unsignRes);
 
       return {
@@ -114,7 +130,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 +180,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 +211,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 +242,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,4 +1,4 @@
-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";
 
@@ -67,8 +67,8 @@ export class DogecoinUtils {
     // Add outputs
     for (const output of tx.outputs) {
       psbt.addOutput({
+        value: output.amount,
         address: output.address,
-        value: BigInt(output.amount),
       });
     }
 
@@ -94,6 +94,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 +105,74 @@ 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];
+        // Reverse the hash to get the correct byte order (bitcoin uses little-endian)
+        const hash = Buffer.from(input.hash).reverse().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,
+          nonWitnessUtxo: input.script,
+        };
+
+        // 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: Number(output.value),
+          });
+        } catch (error) {
+          // If address extraction fails (e.g., OP_RETURN), add output with script and value
+          psbt.addOutput({
+            script: output.script,
+            value: Number(output.value),
+          });
+        }
+      }
+
+      // 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)}`,
+      );
+    }
+  }
 }