@tomo-inc/chains-service 0.0.7 → 0.0.9

package/package.json

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

package/src/api/network-data.ts

@@ -30,12 +30,40 @@ 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: 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,
+      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/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");
   }