@runesx/api-client 0.0.6 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runesx/api-client",
-  "version": "0.0.6",
+  "version": "0.2.0",
   "description": "A Node.js client for interacting with the RunesX platform API and WebSocket",
   "main": "src/index.mjs",
   "type": "module",
@@ -22,10 +22,10 @@
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/npm": "^13.1.4",
-    "dotenv": "^17.2.4",
+    "dotenv": "^17.3.1",
     "eslint": "^9.11.1",
     "eslint-plugin-import": "^2.30.0",
-    "eslint-plugin-n": "^17.23.2",
+    "eslint-plugin-n": "^17.24.0",
     "eslint-plugin-promise": "^7.1.0",
     "globals": "^17.3.0",
     "jest": "^30.2.0",

package/src/api.mjs

@@ -1,4 +1,6 @@
 // src/api.mjs
+import { randomUUID } from 'crypto';
+
 import axios from 'axios';
 
 export function createApi(config) {
@@ -19,32 +21,59 @@ export function createApi(config) {
     }
   }
 
-  async function postSwap({ amountIn, path, minAmountOut }) {
+  async function postSwap({ amountIn, path, minAmountOut, idempotencyKey }) {
     try {
-      const response = await api.post('/swap', { amountIn, path, minAmountOut });
+      const key = idempotencyKey || randomUUID();
+      const response = await api.post('/swap', { amountIn, path, minAmountOut }, {
+        headers: { 'X-Idempotency-Key': key },
+      });
       return response.data;
     } catch (error) {
       throw new Error(error.response?.data?.error || 'Failed to execute swap');
     }
   }
 
-  async function depositLiquidity({ coinA, coinB, amountA, amountB }) {
+  async function depositLiquidity({ tickerA, tickerB, amountA, amountB, minShares, idempotencyKey }) {
     try {
-      const response = await api.post('/liquidity/deposit', { coinA, coinB, amountA, amountB });
+      const key = idempotencyKey || randomUUID();
+      const headers = { 'X-Idempotency-Key': key };
+      const body = { tickerA, tickerB, amountA, amountB };
+      if (minShares !== undefined && minShares !== null) {
+        body.minShares = minShares;
+      }
+      const response = await api.post('/liquidity/deposit', body, { headers });
       return response.data.data;
     } catch (error) {
       throw new Error(error.response?.data?.error || 'Failed to deposit liquidity');
     }
   }
 
-  async function withdrawLiquidity({ coinA, coinB, shares }) {
+  async function withdrawLiquidity({ tickerA, tickerB, shares, minAmountA, minAmountB, idempotencyKey }) {
     try {
-      const response = await api.post('/liquidity/withdraw', { coinA, coinB, shares });
+      const key = idempotencyKey || randomUUID();
+      const headers = { 'X-Idempotency-Key': key };
+      const body = { tickerA, tickerB, shares };
+      if (minAmountA !== undefined && minAmountA !== null) {
+        body.minAmountA = minAmountA;
+      }
+      if (minAmountB !== undefined && minAmountB !== null) {
+        body.minAmountB = minAmountB;
+      }
+      const response = await api.post('/liquidity/withdraw', body, { headers });
       return response.data.data;
     } catch (error) {
       throw new Error(error.response?.data?.error || 'Failed to withdraw liquidity');
     }
   }
 
-  return { getWallets, postSwap, depositLiquidity, withdrawLiquidity };
-}
+  async function getPools() {
+    try {
+      const response = await api.get('/pools');
+      return response.data.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch pools');
+    }
+  }
+
+  return { getWallets, getPools, postSwap, depositLiquidity, withdrawLiquidity };
+}

package/src/index.mjs

@@ -7,7 +7,7 @@ import { getCoins, getCoinByTicker } from './store/coinStore.mjs';
 import { getWallets as getWalletsStore, getWalletByTicker } from './store/walletStore.mjs';
 import { getUserShares, getUserShareByPoolId } from './store/userSharesStore.mjs';
 import { waitForStores } from './waitForStores.mjs';
-import { estimateLiquidityFrontend, checkRunesLiquidityFrontend, calculateShareAmounts } from './utils/liquidityUtils.mjs';
+import { estimateLiquidityFrontend, checkRunesLiquidityFrontend, calculateShareAmounts, estimateDepositShares } from './utils/liquidityUtils.mjs';
 import { estimateSwap } from './utils/swapUtils.mjs';
 import { createPriceUtils } from './utils/priceUtils.mjs';
 
@@ -54,6 +54,8 @@ export function createRunesXClient(options = {}) {
     estimateSwap: (inputCoin, outputCoin, amountIn, maxHops = 6, algorithm = 'dfs') =>
       estimateSwap(inputCoin, outputCoin, amountIn, getPools(), getCoins(), maxHops, algorithm),
     estimateLiquidityFrontend,
+    estimateDepositShares: ({ pool, amountA, amountB, slippagePercent } = {}) =>
+      estimateDepositShares({ pool, amountA, amountB, slippagePercent }),
     checkRunesLiquidityFrontend: (coinA, coinB) =>
       checkRunesLiquidityFrontend(coinA, coinB, getPools(), getCoins()),
     calculateShareAmounts: () => calculateShareAmounts({ userShares: getUserShares(), pools: getPools() }),

package/src/utils/liquidityUtils.mjs

@@ -174,6 +174,66 @@ export function estimateLiquidityFrontend({ coinA, coinB, amountA, amountB, pool
   };
 }
 
+/**
+ * Estimate the shares that would be minted for a liquidity deposit.
+ * Uses the same formula as the backend engine.
+ *
+ * @param {Object} params
+ * @param {Object} params.pool - Pool object from getPools() (must include reserveA, reserveB, totalShares, coinA.dp, coinB.dp)
+ * @param {string} params.amountA - Decimal amount of tokenA to deposit
+ * @param {string} params.amountB - Decimal amount of tokenB to deposit
+ * @param {number} [params.slippagePercent=2] - Slippage tolerance percentage (e.g. 2 for 2%)
+ * @returns {{ estimatedShares: string, minShares: string } | null} null if shares cannot be estimated
+ */
+export function estimateDepositShares({ pool, amountA, amountB, slippagePercent = 2 }) {
+  if (!pool || !amountA || !amountB) {
+    return null;
+  }
+
+  const dpA = pool.coinA.dp;
+  const dpB = pool.coinB.dp;
+  const amountABN = new BigNumber(amountA).decimalPlaces(dpA, BigNumber.ROUND_DOWN);
+  const amountBBN = new BigNumber(amountB).decimalPlaces(dpB, BigNumber.ROUND_DOWN);
+
+  if (!amountABN.isFinite() || !amountBBN.isFinite() || amountABN.lte(0) || amountBBN.lte(0)) {
+    return null;
+  }
+
+  const reserveA = new BigNumber(pool.reserveA);
+  const reserveB = new BigNumber(pool.reserveB);
+  const isNewPool = reserveA.isZero() && reserveB.isZero();
+
+  let shares;
+  if (isNewPool) {
+    // New pool: sqrt(amountA * amountB) * 10^9
+    shares = amountABN.times(amountBBN).sqrt().shiftedBy(9).integerValue(BigNumber.ROUND_DOWN);
+  } else {
+    // Existing pool: min((wholeCoinA * totalShares / reserveA), (wholeCoinB * totalShares / reserveB))
+    const totalShares = new BigNumber(pool.totalShares);
+    if (totalShares.isZero() || reserveA.isZero() || reserveB.isZero()) {
+      return null;
+    }
+
+    const wholeCoinA = amountABN.shiftedBy(dpA).integerValue(BigNumber.ROUND_DOWN);
+    const wholeCoinB = amountBBN.shiftedBy(dpB).integerValue(BigNumber.ROUND_DOWN);
+    const sharesFromA = wholeCoinA.times(totalShares).div(reserveA).integerValue(BigNumber.ROUND_DOWN);
+    const sharesFromB = wholeCoinB.times(totalShares).div(reserveB).integerValue(BigNumber.ROUND_DOWN);
+    shares = BigNumber.min(sharesFromA, sharesFromB);
+  }
+
+  if (shares.isZero()) {
+    return null;
+  }
+
+  const slippageMultiplier = new BigNumber(1).minus(new BigNumber(slippagePercent).div(100));
+  const minShares = shares.times(slippageMultiplier).integerValue(BigNumber.ROUND_DOWN).toString();
+
+  return {
+    estimatedShares: shares.toString(),
+    minShares,
+  };
+}
+
 export function calculateShareAmounts({ userShares, pools }) {
   return userShares.map(share => {
     const pool = pools.find(p => p.id === share.poolId);

package/src/utils/swapUtils.mjs

@@ -10,9 +10,11 @@ export const validatePositiveNumber = (value, fieldName) => {
 };
 
 // Get RUNES price in USD using RUNES/USDC pool
-export const getRunesPriceUSD = async (pools) => {
+export const getRunesPriceUSD = (pools) => {
   try {
-    const runesUsdcPool = pools.find((p) => (p.coinA.ticker === 'RUNES' && p.coinB.ticker === 'USDC'));
+    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');
@@ -63,8 +65,8 @@ export const getTokenPriceInRunes = (token, pools) => {
   const reserveB = new BigNumber(pool.reserveB).shiftedBy(-pool.coinB.dp);
 
   const priceInRunes = isRunesA
-    ? reserveA.div(reserveB).toString() // RUNES/TOKEN: price = reserveB (TOKEN) / reserveA (RUNES)
-    : reserveB.div(reserveA).toString(); // TOKEN/RUNES: price = reserveA (TOKEN) / reserveB (RUNES)
+    ? reserveA.div(reserveB).toString() // RUNES is coinA: price = RUNES_reserve / TOKEN_reserve
+    : reserveB.div(reserveA).toString(); // RUNES is coinB: price = RUNES_reserve / TOKEN_reserve
 
   return priceInRunes;
 };
@@ -74,6 +76,18 @@ const findAllPathsDFS = (startCoin, endCoin, pools, maxHops = 6) => {
   const paths = [];
   const visited = new Set();
 
+  // Build adjacency map for O(1) lookups (matches BFS approach)
+  const poolMap = new Map();
+  pools.forEach((pool) => {
+    if (!pool.runesCompliant || new BigNumber(pool.reserveA).isZero() || new BigNumber(pool.reserveB).isZero()) {return;}
+    const keyA = pool.coinA.ticker;
+    const keyB = pool.coinB.ticker;
+    if (!poolMap.has(keyA)) {poolMap.set(keyA, []);}
+    if (!poolMap.has(keyB)) {poolMap.set(keyB, []);}
+    poolMap.get(keyA).push({ pool, nextCoin: pool.coinB });
+    poolMap.get(keyB).push({ pool, nextCoin: pool.coinA });
+  });
+
   function dfs(currentCoin, currentPath, hops) {
     if (hops > maxHops) {return;}
     if (currentCoin.ticker === endCoin.ticker) {
@@ -81,13 +95,8 @@ const findAllPathsDFS = (startCoin, endCoin, pools, maxHops = 6) => {
       return;
     }
 
-    for (const pool of pools) {
-      if (!pool.runesCompliant) {continue;}
-      const isCoinA = pool.coinA.ticker === currentCoin.ticker;
-      const isCoinB = pool.coinB.ticker === currentCoin.ticker;
-      if (!isCoinA && !isCoinB) {continue;}
-
-      const nextCoin = isCoinA ? pool.coinB : pool.coinA;
+    const connectedPools = poolMap.get(currentCoin.ticker) || [];
+    for (const { pool, nextCoin } of connectedPools) {
       const poolKey = pool.id;
 
       if (visited.has(poolKey)) {continue;}
@@ -175,7 +184,11 @@ export const simulateSwap = (pool, inputCoin, amountInBN, isCoinAInput) => {
   const totalFeeRate = lpFeeRate.plus(treasuryFeeRate);
 
   // Calculate total fee and split proportionally
-  const totalFeeAmount = amountInBN.times(totalFeeRate).integerValue(BigNumber.ROUND_DOWN);
+  let totalFeeAmount = amountInBN.times(totalFeeRate).integerValue(BigNumber.ROUND_DOWN);
+  // Minimum fee floor: match backend - ensure at least 1 smallest unit when fees are configured
+  if (totalFeeRate.gt(0) && totalFeeAmount.isZero()) {
+    totalFeeAmount = new BigNumber(1);
+  }
   let treasuryFeeAmount = new BigNumber(0);
   let lpFeeAmount = new BigNumber(0);
   if (!totalFeeRate.eq(0)) {
@@ -197,7 +210,7 @@ export const simulateSwap = (pool, inputCoin, amountInBN, isCoinAInput) => {
   }
   amountOutBN = amountOutBN.integerValue(BigNumber.ROUND_DOWN);
 
-  if (amountOutBN.isNaN() || amountOutBN.lt(1)) {return null;}
+  if (amountOutBN.isNaN() || !amountOutBN.isFinite() || amountOutBN.lt(1)) {return null;}
 
   // Simulate reserve updates (mimicking backend)
   const updatedPool = { ...pool };
@@ -362,7 +375,7 @@ export const estimateSwap = async (
   const runesPriceUSD = await getRunesPriceUSD(pools);
   const priceAInRunes = getTokenPriceInRunes(inputCoinData, pools);
   const priceBInRunes = getTokenPriceInRunes(outputCoinData, pools);
-  if (!priceAInRunes || !priceBInRunes) {
+  if (!priceAInRunes || priceAInRunes === '0' || !priceBInRunes || priceBInRunes === '0') {
     throw new Error('Pool not initialized or invalid token');
   }
 
@@ -375,48 +388,11 @@ export const estimateSwap = async (
     .times(priceBUSD)
     .toString();
 
-  // Simulate after-swap prices
-  let priceAInRunesAfter = new BigNumber(priceAInRunes);
-  let priceBInRunesAfter = new BigNumber(priceBInRunes);
-  let currentAmount = new BigNumber(amountIn).shiftedBy(inputCoinData.dp || 8);
-  let currentCoin = inputCoinData;
-  let updatedPools = [...pools]; // Clone pools for after-swap price simulation
-
-  for (const step of bestPath) {
-    const poolIndex = updatedPools.findIndex(
-      (p) =>
-        (p.coinA.ticker === step.from && p.coinB.ticker === step.to) ||
-        (p.coinB.ticker === step.from && p.coinA.ticker === step.to)
-    );
-    const pool = updatedPools[poolIndex];
-    const isCoinAInput = pool.coinA.ticker === step.from;
-    const nextCoin = coins.find((c) => c.ticker === step.to);
-    const swapResult = simulateSwap(pool, currentCoin, currentAmount, isCoinAInput);
-
-    const reserveA = new BigNumber(pool.reserveA);
-    const reserveB = new BigNumber(pool.reserveB);
-    if (isCoinAInput) {
-      const newRunesReserve = reserveA.plus(currentAmount);
-      const newTokenReserve = reserveB.minus(swapResult.amountOut);
-      if (step.from === 'RUNES') {
-        priceAInRunesAfter = newRunesReserve.div(newTokenReserve);
-      } else if (step.to === 'RUNES') {
-        priceBInRunesAfter = newRunesReserve.div(newTokenReserve);
-      }
-    } else {
-      const newTokenReserve = reserveB.plus(currentAmount);
-      const newRunesReserve = reserveA.minus(swapResult.amountOut);
-      if (step.from === 'RUNES') {
-        priceAInRunesAfter = newRunesReserve.div(newTokenReserve);
-      } else if (step.to === 'RUNES') {
-        priceBInRunesAfter = newRunesReserve.div(newTokenReserve);
-      }
-    }
-
-    currentAmount = swapResult.amountOut;
-    currentCoin = nextCoin;
-    updatedPools[poolIndex] = swapResult.updatedPool; // Update pool for next iteration
-  }
+  // After-swap prices: use the already-simulated updated pools from bestResult
+  // (estimatePath already tracks post-swap reserve states, no need to re-simulate)
+  const runesPriceUSDAfter = getRunesPriceUSD(bestResult.updatedPools);
+  const priceAInRunesAfter = new BigNumber(getTokenPriceInRunes(inputCoinData, bestResult.updatedPools));
+  const priceBInRunesAfter = new BigNumber(getTokenPriceInRunes(outputCoinData, bestResult.updatedPools));
 
   return {
     input: {
@@ -438,8 +414,8 @@ export const estimateSwap = async (
       intermediateAmounts: bestResult.intermediateAmounts,
     },
     afterSwapPrices: {
-      [inputCoin.ticker]: priceAInRunesAfter.times(runesPriceUSD).toString(),
-      [outputCoin.ticker]: priceBInRunesAfter.times(runesPriceUSD).toString(),
+      [inputCoin.ticker]: priceAInRunesAfter.times(runesPriceUSDAfter).toString(),
+      [outputCoin.ticker]: priceBInRunesAfter.times(runesPriceUSDAfter).toString(),
     },
     path: bestPath,
     algorithm, // Include algorithm in the response