@tomo-inc/chains-service 0.0.2

package/src/dogecoin/rpc.ts

@@ -0,0 +1,449 @@
+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";
+
+export const mydoge = axios.create({
+  baseURL: MYDOGE_BASE_URL,
+});
+
+const api = axios.create({
+  baseURL: RPC_URL,
+  timeout: RPC_TIMEOUT,
+});
+
+export async function getBalance(address?: string) {
+  if (!address) {
+    return {
+      address: "",
+      balance: 0,
+    };
+  }
+  const path = `/address/${address}?page=1&pageSize=10`;
+  const api = `${MYDOGE_BASE_URL}/wallet/info?route=` + encodeURIComponent(path);
+
+  const res: any = await mydoge.get(api);
+  return res.data || {};
+}
+
+export type Drc20Transaction = {
+  blockHash: string;
+  blockHeight: number;
+  blockTime: number;
+  confirmations: number;
+  fees: string;
+  hex: string;
+  size: number;
+  txid: string;
+  value: string;
+  valueIn: string;
+  version: number;
+  vin: {
+    addresses: string[];
+    hex: string;
+    isAddress: boolean;
+    n: number;
+    sequence: number;
+    txid: string;
+    value: string;
+  }[];
+  vout: {
+    addresses: string[];
+    value: string;
+    n: number;
+    hex: string;
+    isAddress: boolean;
+  }[];
+  tick?: string;
+  tickAmount?: number;
+  drc20Detail?: Drc20Detail;
+};
+export async function getTxDetail(txId: string): Promise<Drc20Transaction> {
+  if (!txId) {
+    return {} as Drc20Transaction;
+  }
+  const path = `/tx/${txId}`;
+  const api = `${MYDOGE_BASE_URL}/wallet/info?route=` + encodeURIComponent(path);
+
+  const res = await mydoge.get(api);
+
+  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,
+  result: any,
+  filter: string,
+  tx: { txid: string; vout: number } | null = null,
+): Promise<DogeSpendableUtxos[] | undefined> {
+  const query = (
+    await mydoge.get(`${MYDOGE_BASE_URL}/utxos/${address}?filter=${filter}${cursor ? `&cursor=${cursor}` : ""}`)
+  ).data;
+
+  let { utxos } = query;
+
+  if (tx) {
+    utxos = utxos.filter((utxo: any) => utxo.txid === tx?.txid && utxo.vout === tx?.vout);
+  }
+
+  result.push(
+    ...utxos.map((i: any) => ({
+      txid: i.txid,
+      vout: i.vout,
+      outputValue: i.satoshis,
+      script: i.script_pubkey,
+      ...(filter === "inscriptions" && { inscriptions: i.inscriptions }),
+    })),
+  );
+
+  if (result.length && tx) {
+    return;
+  }
+
+  result = result.sort((a: any, b: any) => toBitcoin(b.outputValue) - toBitcoin(a.outputValue));
+
+  if (query.next_cursor) {
+    return getUtxos(address, query.next_cursor, result, filter, tx);
+  }
+}
+
+export async function getInscriptionsUtxos(address: string) {
+  const inscriptions: any[] = [];
+  await getUtxos(address, 0, inscriptions, "inscriptions");
+
+  return inscriptions;
+}
+
+export async function getSpendableUtxos(address: string) {
+  const utxos: any[] = [];
+  await getUtxos(address, 0, utxos, "spendable");
+
+  return utxos;
+}
+
+export async function getUnSpentUtxos(address: string) {
+  try {
+    const result = await api.get(`/address/${address}/?unspent=true&limit=${0}`);
+    const unSpentUtxo = result?.data;
+    if (unSpentUtxo?.length) return unSpentUtxo.filter((utxo: any) => !utxo.spentTxid);
+    return [];
+  } catch (e) {
+    return [];
+  }
+}
+
+export async function getInscriptionsUtxo(address: string, tx: any) {
+  const inscriptions: any[] = [];
+  await getUtxos(address, 0, inscriptions, "inscriptions", tx);
+
+  return inscriptions[0];
+}
+
+export async function sendTransaction({ signed, senderAddress }: any) {
+  // const signed = signRawTx(
+  //   data.rawTx,
+  //   decryptedWallet.children[selectedAddressIndex],
+  // );
+
+  const jsonrpcReq = {
+    jsonrpc: "2.0",
+    id: `${senderAddress}_send_${Date.now()}`,
+    method: "sendrawtransaction",
+    params: [signed],
+  };
+  const jsonrpcRes = (await mydoge.post("/wallet/rpc", jsonrpcReq)).data;
+  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",
+    id: `${senderAddress}_estimatesmartfee_${Date.now()}`,
+    method: "estimatesmartfee",
+    params: [BLOCK_CONFIRMATIONS], // confirm within x blocks
+  };
+  const feeData = (await mydoge.post("/wallet/rpc", smartfeeReq)).data;
+  const feeRate = feeData?.result?.feerate || FEE_RATE_KB;
+  const feePerKB = toSatoshi(feeRate * 2);
+
+  return { feePerKB };
+}
+
+// Build a raw transaction and determine fee
+export async function onCreateTransaction({ data, sendResponse }: { data: any; sendResponse: any }) {
+  const amountSatoshi = toSatoshi(data.dogeAmount);
+  const amount = toBitcoin(amountSatoshi);
+
+  try {
+    const response = await mydoge.post("/v3/tx/prepare", {
+      sender: data.senderAddress,
+      recipient: data.recipientAddress,
+      amount,
+    });
+    const { rawTx, fee, amount: resultAmount } = response.data;
+    let amountMismatch = false;
+
+    if (resultAmount < amount - fee) {
+      amountMismatch = true;
+    }
+
+    sendResponse?.({
+      rawTx,
+      fee,
+      amount: resultAmount,
+      amountMismatch,
+    });
+  } catch (err) {
+    sendResponse?.(false);
+  }
+}
+
+export type Drc20TransactionResponse = {
+  transactions: Drc20Transaction[];
+  txIds: string[];
+  totalPages: number;
+  page: number;
+};
+
+export async function getTransactions(
+  address: string,
+  config?: {
+    pageSize: number;
+    pageNumber: number;
+  },
+): Promise<Drc20TransactionResponse> {
+  const { pageSize = 10, pageNumber = 1 } = config || {};
+  const size = Math.min(pageSize, TRANSACTION_PAGE_SIZE);
+  // Get txids
+  let txIds = [];
+  let totalPages;
+  let page;
+
+  try {
+    const response = (
+      await mydoge.get("/wallet/info", {
+        params: {
+          route: `/address/${address}?page=${pageNumber}&pageSize=${size}`,
+        },
+      })
+    ).data;
+
+    txIds = response.txids;
+    totalPages = response.totalPages;
+    page = response.page;
+
+    const res = await Promise.all(
+      txIds?.map(async (txId: string) => {
+        const detail = await getTxDetail(txId);
+        const tx = new TransactionParser(detail.hex);
+        const parsedData: any = tx.parseScript();
+        return {
+          ...detail,
+          tick: parsedData?.opReturnData?.tick,
+          tickAmount: parsedData?.opReturnData?.amt,
+        };
+      }) || [],
+    );
+
+    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 };
+  } catch (err) {
+    throw new Error("getTransactions failed");
+  }
+}
+
+export const getDogeFeeByBlock = async (address?: string, n = 22) => {
+  const res = await api.get(`/fee/${n}`);
+  return (res.data?.feerate || 0.01) * TX_SIZE;
+};
+
+export const sendDogeTx = async (rawTx: string) => {
+  try {
+    const res = await api.post("/tx/send", { rawTx });
+    return res.data;
+  } catch (e: any) {
+    if (typeof e?.response?.data === "string") return Promise.reject(e?.response?.data);
+    else return Promise.reject(e.message);
+  }
+};