@tomo-inc/chains-service 0.0.8 → 0.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomo-inc/chains-service",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "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.7"
+    "@tomo-inc/wallet-utils": "0.0.8"
   },
   "devDependencies": {
     "@types/supertest": "^2.0.12",

package/src/api/network-data.ts

@@ -43,6 +43,20 @@ export const loadNetworks = (WALLET_DOMAIN: string) => {
       supportGift: false,
       supportHistory: true,
     },
+    {
+      chainId: 36888,
+      chainIndex: 3688800,
+      name: "ABCORE",
+      chainName: "AB Core",
+      rpcUrls: ["https://rpc1.core.ab.org"],
+      blockExplorerUrl: "https://explorer.core.ab.org",
+      platformType: "EVM",
+      isTestnet: false,
+      icon: "/assets/ab.svg",
+      supportSwap: true,
+      supportGift: false,
+      supportHistory: true,
+    },
     {
       chainId: 6281971,
       chainIndex: 628197100,

package/src/dogecoin/rpc.ts

@@ -3,8 +3,7 @@ import axios from "axios";
 import { TRANSACTION_PAGE_SIZE, BLOCK_CONFIRMATIONS, FEE_RATE_KB } from "./config";
 import { RPC_URL, MYDOGE_BASE_URL, RPC_TIMEOUT, TX_SIZE } from "./config";
 import { TransactionParser, toSatoshi, toBitcoin } from "./utils";
-import { cache } from "@tomo-inc/wallet-utils";
-import { DogeSpendableUtxos, DunesTransactionParams } from "./type";
+import { DogeSpendableUtxos } from "./type";
 
 export const mydoge = axios.create({
   baseURL: MYDOGE_BASE_URL,
@@ -29,7 +28,7 @@ export async function getBalance(address?: string) {
   return res.data || {};
 }
 
-export type Drc20Transaction = {
+export type Transaction = {
   blockHash: string;
   blockHeight: number;
   blockTime: number;
@@ -57,13 +56,11 @@ export type Drc20Transaction = {
     hex: string;
     isAddress: boolean;
   }[];
-  tick?: string;
-  tickAmount?: number;
-  drc20Detail?: Drc20Detail;
 };
-export async function getTxDetail(txId: string): Promise<Drc20Transaction> {
+
+export async function getTxDetail(txId: string): Promise<Transaction> {
   if (!txId) {
-    return {} as Drc20Transaction;
+    return {} as Transaction;
   }
   const path = `/tx/${txId}`;
   const api = `${MYDOGE_BASE_URL}/wallet/info?route=` + encodeURIComponent(path);
@@ -73,59 +70,6 @@ export async function getTxDetail(txId: string): Promise<Drc20Transaction> {
   return res.data || {};
 }
 
-export async function getAccountDrc20List(address: string, config?: any) {
-  const api = `/drc20/${address}`;
-  const res: any = await mydoge.get(api);
-  return res.data || {};
-}
-
-const Drc20DetailsCacheKey = "Drc20Details";
-const Drc20DetailsCache = cache.get(Drc20DetailsCacheKey) || {};
-function isCacheAvailable(time: number) {
-  const cacheTime = 20 * 60 * 1000; // 30 minutes
-  return Date.now() - time <= cacheTime;
-}
-export type Drc20Detail = {
-  changePercent: string;
-  currentSupply: number;
-  floorPrice: number;
-  holders: number;
-  lastPrice: number;
-  maxSupply: number;
-  pic: string;
-  sales: number;
-  tick: string;
-  twentyFourHourVolume: string;
-  volume: string;
-};
-export async function getDrc20Detail(ticker: string): Promise<Drc20Detail> {
-  const drc20Detail = Drc20DetailsCache?.[ticker];
-  if (drc20Detail?.cacheTime && isCacheAvailable(drc20Detail?.cacheTime)) {
-    return drc20Detail;
-  }
-
-  const api = `/drc20/data/${ticker}`;
-  const res: any = await mydoge.get(api);
-  const detail = res.data || {};
-  if (detail.pic) {
-    Drc20DetailsCache[ticker] = { ...detail, cacheTime: Date.now() };
-    cache.set(Drc20DetailsCacheKey, Drc20DetailsCache, false);
-  }
-  return detail;
-}
-
-export async function getDRC20Inscriptions(address: string, ticker: string) {
-  const api = `${MYDOGE_BASE_URL}/inscriptions/${address}?filter=drc20&ticker=${encodeURIComponent(ticker)}`;
-  const query = (await mydoge.get(api)).data;
-  return query;
-}
-
-export async function getDRC20Balance(address: string, ticker: string) {
-  const api = `${MYDOGE_BASE_URL}/drc20/${address}?ticker=${ticker}`;
-  const res = (await mydoge.get(api))?.data || {};
-  return res;
-}
-
 async function getUtxos(
   address: string,
   cursor: number,
@@ -212,100 +156,6 @@ export async function sendTransaction({ signed, senderAddress }: any) {
   return jsonrpcRes;
 }
 
-//nft
-export async function getNFTs(address?: string): Promise<{ list: any[]; total: number }> {
-  if (!address) {
-    throw new Error("address is required");
-  }
-
-  const res: any = await mydoge.get(`/inscriptions/${address}`);
-  const { list = [], total = 0 } = res?.data || {};
-  return { list, total };
-}
-
-export async function createNFTTransaction(params: {
-  senderAddress: string;
-  recipientAddress: string;
-  location: string;
-  inscriptionId: string;
-}) {
-  const { senderAddress, recipientAddress, location, inscriptionId } = params;
-  try {
-    const res: any = await mydoge.post("/tx/prepare/inscription", {
-      sender: senderAddress,
-      recipient: recipientAddress,
-      location: location,
-      inscriptionId: inscriptionId,
-    });
-    const { rawTx, fee, amount } = res?.data || {};
-
-    return {
-      rawTx,
-      fee,
-      amount,
-    };
-  } catch (err) {
-    console.error("createNFTTransaction", err);
-    return {};
-  }
-}
-
-//dunes
-export async function getDunesBalance(address: string, ticker?: string) {
-  const api = `/dunes/${address}${ticker ? `?ticker=${ticker}` : ""}`;
-  const res = (await mydoge.get(api))?.data || {};
-  return res;
-}
-
-const DuneDetailsCacheKey = "DuneDetails";
-const DuneDetailsCache = cache.get(DuneDetailsCacheKey) || {};
-export async function getDuneDetail(ticker: string): Promise<Drc20Detail> {
-  const duneDetail = DuneDetailsCache?.[ticker];
-  if (duneDetail?.cacheTime && isCacheAvailable(duneDetail?.cacheTime)) {
-    return duneDetail;
-  }
-  try {
-    const api = `/dunes/data/${ticker}`;
-    const res: any = await mydoge.get(api);
-    const detail = res.data || {};
-    if (detail.pic) {
-      DuneDetailsCache[ticker] = { ...detail, cacheTime: Date.now() };
-      cache.set(DuneDetailsCacheKey, DuneDetailsCache, false);
-    }
-    return detail;
-  } catch (err) {
-    throw new Error("dune detail not found");
-  }
-}
-
-export async function createDunesTransaction(params: DunesTransactionParams) {
-  try {
-    const { senderAddress = "", recipientAddress = "", amount = 0, ticker = "" } = params;
-    const { balances = [] } = await getDunesBalance(senderAddress, ticker);
-    const { duneId } = balances[0] || {};
-    if (!duneId) {
-      throw new Error("duneId not found");
-    }
-    const response = await mydoge.post("/tx/prepare/dune", {
-      sender: senderAddress,
-      recipient: recipientAddress,
-      amount,
-      duneId,
-    });
-
-    const { rawTx, fee, inputs } = response.data;
-
-    return {
-      rawTx,
-      fee,
-      inputs, // usingUtxos
-    };
-  } catch (err) {
-    console.error("createDunesTransaction", err);
-    return {};
-  }
-}
-
 export async function estimateSmartFee({ senderAddress }: { senderAddress: string }) {
   const smartfeeReq = {
     jsonrpc: "2.0",
@@ -349,8 +199,8 @@ export async function onCreateTransaction({ data, sendResponse }: { data: any; s
   }
 }
 
-export type Drc20TransactionResponse = {
-  transactions: Drc20Transaction[];
+export type TransactionResponse = {
+  transactions: Transaction[];
   txIds: string[];
   totalPages: number;
   page: number;
@@ -362,7 +212,7 @@ export async function getTransactions(
     pageSize: number;
     pageNumber: number;
   },
-): Promise<Drc20TransactionResponse> {
+): Promise<TransactionResponse> {
   const { pageSize = 10, pageNumber = 1 } = config || {};
   const size = Math.min(pageSize, TRANSACTION_PAGE_SIZE);
   // Get txids
@@ -383,7 +233,7 @@ export async function getTransactions(
     totalPages = response.totalPages;
     page = response.page;
 
-    const res = await Promise.all(
+    const transactions = await Promise.all(
       txIds?.map(async (txId: string) => {
         const detail = await getTxDetail(txId);
         const tx = new TransactionParser(detail.hex);
@@ -396,38 +246,7 @@ export async function getTransactions(
       }) || [],
     );
 
-    const filterTickList = [...new Set(res.map((item) => item.tick).filter((i) => i))];
-    const tickList = [];
-    for (const item of filterTickList) {
-      try {
-        const detail = await getDrc20Detail(item);
-        tickList.push(detail);
-      } catch (err) {
-        console.error(`Failed to fetch detail for ${item}`, err);
-        tickList.push({ tick: item });
-      }
-    }
-    // const tickList = await throttledMap(
-    //   filterTickList,
-    //   async (item) => {
-    //     try {
-    //       return await getDrc20Detail(item);
-    //     } catch (err) {
-    //       console.error(`Failed to fetch detail for ${item}`, err);
-    //       return { tick: item };
-    //     }
-    //   },
-    //   1,
-    // );
-    const tickMap = tickList.reduce((acc, cur) => {
-      acc[cur.tick] = cur;
-      return acc;
-    }, {} as any);
-    res.forEach((item) => {
-      item.drc20Detail = tickMap[item.tick];
-    });
-
-    return { transactions: res || [], txIds, totalPages, page };
+    return { transactions, txIds, totalPages, page };
   } catch (err) {
     throw new Error("getTransactions failed");
   }

package/src/dogecoin/service.ts

@@ -19,10 +19,12 @@ 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) {
     super(tomoAppInfo, accountInfo);
     this.chainType = chainType;
+    this.rpcService = API;
   }
 
   //singleton
@@ -106,22 +108,6 @@ export class DogecoinService extends BaseService {
     });
   }
 
-  public async requestDecryptedMessage({ message }: { message: string }): Promise<{ decryptedMessage: string }> {
-    try {
-      if (!this.accountInfo?.decryptedMessage) {
-        throw new Error("decryptedMessage is not supported");
-      }
-      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 = {

package/src/dogecoin/utils-doge.ts

@@ -1,6 +1,7 @@
 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,7 +68,7 @@ export class DogecoinUtils {
     // Add outputs
     for (const output of tx.outputs) {
       psbt.addOutput({
-        value: output.amount,
+        value: BigInt(output?.amount || 0),
         address: output.address,
       });
     }
@@ -129,8 +130,7 @@ export class DogecoinUtils {
       // 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 hash = Buffer.from(input.hash).toString("hex");
         const index = input.index;
 
         // Add input without nonWitnessUtxo initially
@@ -139,9 +139,22 @@ export class DogecoinUtils {
         const inputOptions: any = {
           hash,
           index,
-          nonWitnessUtxo: input.script,
         };
 
+        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);
@@ -154,13 +167,13 @@ export class DogecoinUtils {
           const address = AddressLib.fromOutputScript(output.script, network);
           psbt.addOutput({
             address,
-            value: Number(output.value),
+            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: Number(output.value),
+            value: BigInt(output?.value || 0),
           });
         }
       }

package/src/index.ts

@@ -1,9 +1,9 @@
+import { ChainTypes } from "@tomo-inc/wallet-utils";
+import { DogecoinService } from "./dogecoin/service";
 import { EvmService } from "./evm/service";
 import { SolanaService } from "./solana/service";
-import { DogecoinService } from "./dogecoin/service";
-import { ChainTypes } from "@tomo-inc/wallet-utils";
 
-export { EvmService, SolanaService, DogecoinService };
+export { DogecoinService, EvmService, SolanaService };
 
 export const ChainTypeServices = {
   [ChainTypes.EVM]: EvmService,
@@ -18,8 +18,8 @@ export { TomoWallet } from "./wallet";
 
 export type {
   ChainAddress,
-  IAccountInfo,
   IAccount,
+  IAccountInfo,
   TomoAppInfo,
   TransactionItem,
   TransactionsParams,
@@ -27,3 +27,7 @@ export type {
 } from "./types";
 
 export { AccountType, TxTypes } from "./types";
+
+export * as DogecoinAPI from "./dogecoin/rpc";
+export * from "./dogecoin/utils";
+export * from "./dogecoin/utils-doge";