@runesx/api-client 0.1.0 → 0.3.0

package/package.json

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

package/src/index.mjs

@@ -4,6 +4,7 @@ import { createApi } from './api.mjs';
 import { createConfig } from './config.mjs';
 import { getPools, getPool } from './store/poolStore.mjs';
 import { getCoins, getCoinByTicker } from './store/coinStore.mjs';
+import { getChains, getChainByName } from './store/chainStore.mjs';
 import { getWallets as getWalletsStore, getWalletByTicker } from './store/walletStore.mjs';
 import { getUserShares, getUserShareByPoolId } from './store/userSharesStore.mjs';
 import { waitForStores } from './waitForStores.mjs';
@@ -22,9 +23,9 @@ export function createRunesXClient(options = {}) {
       throw new Error('API_KEY is required');
     }
     socket = setupSocket(config).socket;
-    const { pools, coins, wallets, userShares } = await waitForStores(socket);
+    const { pools, coins, chains, wallets, userShares } = await waitForStores(socket);
     initialized = true;
-    return { pools, coins, wallets, userShares };
+    return { pools, coins, chains, wallets, userShares };
   }
 
   function ensureInitialized() {
@@ -43,6 +44,8 @@ export function createRunesXClient(options = {}) {
     getPool,
     getCoins,
     getCoinByTicker,
+    getChains,
+    getChainByName,
     getWallets: getWalletsStore,
     getWalletByTicker,
     getUserShares,

package/src/socket.mjs

@@ -3,12 +3,14 @@ import { io } from 'socket.io-client';
 
 import { setInitialPools, updatePool, resetPools } from './store/poolStore.mjs';
 import { setInitialCoins, updateCoin, resetCoins } from './store/coinStore.mjs';
+import { setInitialChains, updateChain, resetChains } from './store/chainStore.mjs';
 import { setInitialWallets, updateWallet, resetWallets } from './store/walletStore.mjs';
 import { setInitialUserShares, updateUserShare, resetUserShares } from './store/userSharesStore.mjs';
 
 export function setupSocket(config) {
   const socket = io(config.socketUrl, {
     auth: { authorization: `Bearer ${config.apiKey}` },
+    extraHeaders: { authorization: `Bearer ${config.apiKey}` },
     transports: ['websocket'],
     reconnection: true,
     reconnectionAttempts: Infinity,
@@ -30,6 +32,7 @@ export function setupSocket(config) {
     if (errorCount.count >= 3) {
       resetPools();
       resetCoins();
+      resetChains();
       resetWallets();
       resetUserShares();
     }
@@ -39,6 +42,7 @@ export function setupSocket(config) {
     console.log('Disconnected from Socket.IO server:', reason);
     resetPools();
     resetCoins();
+    resetChains();
     resetWallets();
     resetUserShares();
   });
@@ -52,6 +56,7 @@ export function setupSocket(config) {
     socket.emit('join_private');
     resetPools();
     resetCoins();
+    resetChains();
     resetWallets();
     resetUserShares();
   });
@@ -62,6 +67,7 @@ export function setupSocket(config) {
     if (errorCount.count >= 3) {
       resetPools();
       resetCoins();
+      resetChains();
       resetWallets();
       resetUserShares();
     }
@@ -89,6 +95,15 @@ export function setupSocket(config) {
     }
   });
 
+  socket.on('chains_updated', ({ chains, isInitial }) => {
+    // console.log('Received chains_updated:', { chains, isInitial });
+    if (isInitial) {
+      setInitialChains(chains);
+    } else {
+      chains.forEach(chain => updateChain(chain));
+    }
+  });
+
   socket.on('wallets_updated', ({ wallets, isInitial }) => {
     // console.log('Received wallets_updated:', { wallets, isInitial });
     if (isInitial) {
@@ -130,8 +145,8 @@ export function setupSocket(config) {
     // console.log('Status update:', data);
   });
 
-  socket.on('deposit_address_generated', ({ requestId, chainId, address, memo }) => {
-    // console.log('Deposit address generated:', { requestId, chainId, address, memo });
+  socket.on('deposit_address_generated', ({ requestId, chainName, address, memo }) => {
+    // console.log('Deposit address generated:', { requestId, chainName, address, memo });
   });
 
   socket.on('deposit_processed', (data) => {
@@ -227,6 +242,7 @@ export function setupSocket(config) {
     clearInterval(heartbeatInterval);
     resetPools();
     resetCoins();
+    resetChains();
     resetWallets();
     resetUserShares();
   });

package/src/store/chainStore.mjs

@@ -0,0 +1,92 @@
+const chainStore = {
+  chains: new Map(), // Store chain data by name (lowercase)
+  isInitialReceived: false,
+  pendingUpdates: [],
+};
+
+const setInitialChains = (chains) => {
+  chainStore.chains.clear();
+  chains.forEach(chain => {
+    chainStore.chains.set(chain.name.toLowerCase(), {
+      id: chain.id,
+      name: chain.name,
+      blockchainId: chain.blockchainId,
+      requiredConfirmations: chain.requiredConfirmations,
+      hasMemo: chain.hasMemo,
+      status: chain.status,
+      chainType: chain.chainType,
+      nativeTicker: chain.nativeTicker,
+      explorerTxUrl: chain.explorerTxUrl,
+      updatedAt: chain.updatedAt,
+    });
+  });
+  chainStore.isInitialReceived = true;
+
+  if (chainStore.pendingUpdates.length > 0) {
+    chainStore.pendingUpdates.forEach(({ chains }) => {
+      chains.forEach(chain => updateChain(chain));
+    });
+    chainStore.pendingUpdates = [];
+  }
+};
+
+const updateChain = (chain) => {
+  if (!chainStore.isInitialReceived) {
+    chainStore.pendingUpdates.push({ chains: [chain] });
+    return;
+  }
+
+  const key = chain.name.toLowerCase();
+  const existingChain = chainStore.chains.get(key);
+  const incomingUpdatedAt = new Date(chain.updatedAt).getTime();
+
+  if (existingChain) {
+    const existingUpdatedAt = new Date(existingChain.updatedAt).getTime();
+    if (incomingUpdatedAt <= existingUpdatedAt) {
+      return;
+    }
+
+    chainStore.chains.set(key, {
+      ...existingChain,
+      blockchainId: chain.blockchainId,
+      requiredConfirmations: chain.requiredConfirmations,
+      hasMemo: chain.hasMemo,
+      status: chain.status,
+      chainType: chain.chainType,
+      nativeTicker: chain.nativeTicker,
+      explorerTxUrl: chain.explorerTxUrl,
+      updatedAt: chain.updatedAt,
+    });
+  } else if (chain.name && chain.status) {
+    chainStore.chains.set(key, {
+      id: chain.id,
+      name: chain.name,
+      blockchainId: chain.blockchainId,
+      requiredConfirmations: chain.requiredConfirmations,
+      hasMemo: chain.hasMemo,
+      status: chain.status,
+      chainType: chain.chainType,
+      nativeTicker: chain.nativeTicker,
+      explorerTxUrl: chain.explorerTxUrl,
+      updatedAt: chain.updatedAt,
+    });
+  } else {
+    console.warn(`Ignoring update for unknown chain ${chain.name} with incomplete data`);
+  }
+};
+
+const getChains = () => {
+  return Array.from(chainStore.chains.values());
+};
+
+const getChainByName = (name) => {
+  return chainStore.chains.get(name.toLowerCase());
+};
+
+const resetChains = () => {
+  chainStore.chains.clear();
+  chainStore.isInitialReceived = false;
+  chainStore.pendingUpdates = [];
+};
+
+export { chainStore, setInitialChains, updateChain, getChains, getChainByName, resetChains };

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

package/src/waitForStores.mjs

@@ -1,5 +1,6 @@
 import { poolStore, getPools } from './store/poolStore.mjs';
 import { coinStore, getCoins } from './store/coinStore.mjs';
+import { chainStore, getChains } from './store/chainStore.mjs';
 import { walletStore, getWallets } from './store/walletStore.mjs';
 import { userSharesStore, getUserShares } from './store/userSharesStore.mjs';
 
@@ -74,6 +75,41 @@ export function waitForStores(socket) {
     });
   };
 
+  // Function to wait for chainStore to be populated
+  const waitForChains = () => {
+    return new Promise((resolve, reject) => {
+      if (chainStore.isInitialReceived) {
+        const chains = getChains();
+        resolve(chains);
+        return;
+      }
+
+      const timeout = setTimeout(() => {
+        reject(new Error('Timeout waiting for initial chain data'));
+      }, 30000); // 30-second timeout
+
+      socket.on('chains_updated', ({ isInitial }) => {
+        if (isInitial) {
+          const chains = getChains();
+          clearTimeout(timeout);
+          resolve(chains);
+        }
+      });
+
+      socket.on('connect_error', (err) => {
+        console.error('Socket connect error:', err.message);
+        clearTimeout(timeout);
+        reject(new Error('Socket connection failed'));
+      });
+
+      socket.on('disconnect', (reason) => {
+        console.error('Socket disconnected:', reason);
+        clearTimeout(timeout);
+        reject(new Error('Socket disconnected before receiving initial chain data'));
+      });
+    });
+  };
+
   // Function to wait for walletStore to be populated
   const waitForWallets = () => {
     return new Promise((resolve, reject) => {
@@ -145,10 +181,11 @@ export function waitForStores(socket) {
   };
 
   // Return a promise that resolves when all stores are populated
-  return Promise.all([waitForPools(), waitForCoins(), waitForWallets(), waitForUserShares()])
-    .then(([pools, coins, wallets, userShares]) => ({
+  return Promise.all([waitForPools(), waitForCoins(), waitForChains(), waitForWallets(), waitForUserShares()])
+    .then(([pools, coins, chains, wallets, userShares]) => ({
       pools,
       coins,
+      chains,
       wallets,
       userShares,
     }));