@runesx/api-client 0.0.3 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runesx/api-client",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "A Node.js client for interacting with the RunesX platform API and WebSocket",
   "main": "src/index.mjs",
   "type": "module",

package/src/index.mjs

@@ -9,6 +9,7 @@ import { getUserShares, getUserShareByPoolId } from './store/userSharesStore.mjs
 import { waitForStores } from './waitForStores.mjs';
 import { estimateLiquidityFrontend, checkRunesLiquidityFrontend, calculateShareAmounts } from './utils/liquidityUtils.mjs';
 import { estimateSwap } from './utils/swapUtils.mjs';
+import { createPriceUtils } from './utils/priceUtils.mjs';
 
 export function createRunesXClient(options = {}) {
   const config = createConfig(options);
@@ -71,6 +72,9 @@ export function createRunesXClient(options = {}) {
         }
       }, interval);
     },
+    utils: {
+      ...createPriceUtils(),
+    },
     disconnect: () => {
       if (socket) {
         socket.disconnect();

package/src/utils/liquidityUtils.mjs

@@ -1,6 +1,8 @@
 // src/utils/liquidityUtils.mjs
 import { BigNumber } from 'bignumber.js';
 
+import { getRunesPriceUSD, getTokenPriceInRunes } from './swapUtils.mjs';
+
 export function normalizeTokenPairFrontend(coinA, coinB, pools) {
   if (!coinA || !coinB || !coinA.ticker || !coinB.ticker) {
     throw new Error('Invalid token objects');
@@ -210,4 +212,43 @@ export function calculateShareAmounts({ userShares, pools }) {
       pair: `${pool.coinA.ticker}/${pool.coinB.ticker}`,
     };
   });
-}
+}
+
+export const getPoolLiquidityUSD = (pool, coins, pools) => {
+  if (!pool || !coins || !pools || !pool.runesCompliant) {
+    return { value: '0', error: 'Pool or coin data missing or not RUNES compliant' };
+  }
+
+  const coinA = coins.find((c) => c.ticker === pool.coinA.ticker);
+  const coinB = coins.find((c) => c.ticker === pool.coinB.ticker);
+  if (!coinA || !coinB) {
+    return { value: '0', error: `Coins not found: ${pool.coinA.ticker}/${pool.coinB.ticker}` };
+  }
+
+  const reserveA = new BigNumber(pool.reserveA).shiftedBy(-pool.coinA.dp);
+  const reserveB = new BigNumber(pool.reserveB).shiftedBy(-pool.coinB.dp);
+
+  if (reserveA.isZero() || reserveB.isZero()) {
+    return { value: '0', error: 'Zero reserves in pool' };
+  }
+
+  const runesPriceUSD = getRunesPriceUSD(pools);
+  const priceAInRunes = new BigNumber(getTokenPriceInRunes(coinA, pools) || '0');
+  const priceBInRunes = new BigNumber(getTokenPriceInRunes(coinB, pools) || '0');
+
+  const valueA = priceAInRunes.times(runesPriceUSD).times(reserveA);
+  const valueB = priceBInRunes.times(runesPriceUSD).times(reserveB);
+
+  if (valueA.isNaN() || valueB.isNaN() || priceAInRunes.isZero() || priceBInRunes.isZero()) {
+    return {
+      value: '0',
+      error: 'Invalid liquidity data (NaN or zero price)',
+    };
+  }
+
+  const poolValue = valueA.plus(valueB);
+  return {
+    value: poolValue.toString(),
+    error: null,
+  };
+};

package/src/utils/priceUtils.mjs

@@ -0,0 +1,122 @@
+// src/utils/priceUtils.mjs
+import { BigNumber } from 'bignumber.js';
+
+import { getPools } from '../store/poolStore.mjs';
+import { getCoinByTicker } from '../store/coinStore.mjs';
+
+export function createPriceUtils() {
+  const getRunesPriceUSD = () => {
+    const pools = getPools();
+
+    const runesUsdcPool = pools.find((p) =>
+      (p.coinA.ticker === 'RUNES' && p.coinB.ticker === 'USDC') ||
+      (p.coinA.ticker === 'USDC' && p.coinB.ticker === 'RUNES')
+    );
+
+    if (!runesUsdcPool) {
+      console.warn('RUNES/USDC pool not found, using fallback price of $0.01');
+      return '0.01';
+    }
+
+    const reserveA = new BigNumber(runesUsdcPool.reserveA).shiftedBy(-runesUsdcPool.coinA.dp);
+    const reserveB = new BigNumber(runesUsdcPool.reserveB).shiftedBy(-runesUsdcPool.coinB.dp);
+
+    if (reserveA.isZero() || reserveB.isZero()) {
+      console.warn('RUNES/USDC pool has zero reserves, using fallback price of $0.01');
+      return '0.01';
+    }
+
+    const runesPriceUSD = runesUsdcPool.coinA.ticker === 'RUNES'
+      ? reserveB.div(reserveA)
+      : reserveA.div(reserveB);
+
+    if (runesPriceUSD.isNaN() || runesPriceUSD.lte(0)) {
+      console.warn('Invalid RUNES/USDC price calculated, using fallback price of $0.01');
+      return '0.01';
+    }
+
+    return runesPriceUSD.toString();
+  };
+
+  const getTokenPriceInRunes = (ticker) => {
+    ensureInitialized();
+    if (ticker === 'RUNES') {return '1';}
+
+    const pools = getPools();
+    const pool = pools.find(
+      (p) =>
+        (p.coinA.ticker === 'RUNES' && p.coinB.ticker === ticker) ||
+        (p.coinB.ticker === 'RUNES' && p.coinA.ticker === ticker)
+    );
+
+    if (!pool || new BigNumber(pool.reserveA).isZero() || new BigNumber(pool.reserveB).isZero()) {
+      return '0';
+    }
+
+    const reserveA = new BigNumber(pool.reserveA).shiftedBy(-pool.coinA.dp);
+    const reserveB = new BigNumber(pool.reserveB).shiftedBy(-pool.coinB.dp);
+
+    const priceInRunes = pool.coinA.ticker === 'RUNES'
+      ? reserveA.div(reserveB)
+      : reserveB.div(reserveA);
+
+    return priceInRunes.toString();
+  };
+
+  const getTokenPriceUSD = (ticker) => {
+    ensureInitialized();
+    if (ticker === 'USDC') {return '1';}
+
+    const coin = getCoinByTicker(ticker);
+    if (!coin) {
+      console.warn(`Coin not found for ticker ${ticker}`);
+      return '0';
+    }
+
+    const runesPriceUSD = getRunesPriceUSD();
+    const priceInRunes = getTokenPriceInRunes(ticker);
+
+    if (priceInRunes === '0') {return '0';}
+
+    return new BigNumber(priceInRunes).multipliedBy(runesPriceUSD).toString();
+  };
+
+  const getPrices = (tickers) => {
+    const prices = {};
+    for (const ticker of tickers) {
+      try {
+        prices[ticker] = getTokenPriceUSD(ticker);
+      } catch (e) {
+        console.warn(`Failed to get price for ${ticker}:`, e.message);
+        prices[ticker] = null;
+      }
+    }
+    return prices;
+  };
+
+  const calculateUSDValue = (amount, ticker, decimals = null) => {
+    try {
+      const priceUSD = getTokenPriceUSD(ticker);
+      if (priceUSD === '0' || !priceUSD) {return '0.00';}
+
+      let valueBN = new BigNumber(amount).multipliedBy(priceUSD);
+
+      if (decimals !== null) {
+        valueBN = valueBN.dp(decimals, BigNumber.ROUND_DOWN);
+      }
+
+      return valueBN.toString();
+    } catch (error) {
+      console.warn(`Failed to calculate USD value for ${amount} ${ticker}:`, error.message);
+      return '0.00';
+    }
+  };
+
+  return {
+    getRunesPriceUSD,
+    getTokenPriceInRunes,
+    getTokenPriceUSD,
+    getPrices,
+    calculateUSDValue,
+  };
+}