@runesx/api-client 0.5.4 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runesx/api-client",
-  "version": "0.5.4",
+  "version": "0.6.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

@@ -1,5 +1,5 @@
 // src/index.mjs
-import { setupSocket } from './socket.mjs';
+import { setupSocket, setupPublicSocket } from './socket.mjs';
 import { createApi } from './api.mjs';
 import { createConfig } from './config.mjs';
 import { getPools, getPool } from './store/poolStore.mjs';
@@ -10,7 +10,7 @@ import { getUserShares, getUserShareByPoolId } from './store/userSharesStore.mjs
 import { getAllOrderBooks, getOrderBook, getOrderBookPairs, getUserOrders } from './store/orderbookStore.mjs';
 import { getMarkets, getMarketByCoinKey, getMarketByCoins } from './store/marketStore.mjs';
 import { getClobFees } from './store/exchangeConfigStore.mjs';
-import { waitForStores } from './waitForStores.mjs';
+import { waitForStores, waitForSelectiveStores } from './waitForStores.mjs';
 import { estimateLiquidityFrontend, checkRunesLiquidityFrontend, calculateShareAmounts, estimateDepositShares } from './utils/liquidityUtils.mjs';
 import { estimateSwap } from './utils/swapUtils.mjs';
 import { createPriceUtils } from './utils/priceUtils.mjs';
@@ -31,6 +31,13 @@ export function createRunesXClient(options = {}) {
     return { pools, coins, chains, wallets, userShares, orderbooks };
   }
 
+  async function initializePublic({ stores = ['pools', 'coins'] } = {}) {
+    socketHandler = setupPublicSocket(config, stores);
+    const storeData = await waitForSelectiveStores(socketHandler.socket, stores);
+    initialized = true;
+    return storeData;
+  }
+
   function ensureInitialized() {
     if (!initialized) {
       throw new Error('Client not initialized. Call initialize() first.');
@@ -39,6 +46,13 @@ export function createRunesXClient(options = {}) {
 
   return {
     initialize,
+    initializePublic,
+
+    requestStores: (additionalStores) => {
+      ensureInitialized();
+      socketHandler.requestStores(additionalStores);
+      return waitForSelectiveStores(socketHandler.socket, additionalStores);
+    },
 
     // Raw socket access
     getSocket: () => {
@@ -75,13 +89,13 @@ export function createRunesXClient(options = {}) {
     },
 
     // ---- Socket emit convenience methods ----
-    joinCandlesticks: (poolId, timeframe) => {
+    joinCandlesticks: (pair, timeframe) => {
       ensureInitialized();
-      socketHandler.joinCandlesticks(poolId, timeframe);
+      socketHandler.joinCandlesticks(pair, timeframe);
     },
-    leaveCandlesticks: (poolId, timeframe) => {
+    leaveCandlesticks: (pair, timeframe) => {
       ensureInitialized();
-      socketHandler.leaveCandlesticks(poolId, timeframe);
+      socketHandler.leaveCandlesticks(pair, timeframe);
     },
     sendYardMessage: (text) => {
       ensureInitialized();

package/src/socket.mjs

@@ -10,103 +10,12 @@ import { setInitialOrderBooks, updateOrderBook, resetOrderBooks, setUserOrders,
 import { setInitialMarkets, addOrUpdateMarket, resetMarkets } from './store/marketStore.mjs';
 import { setExchangeConfig } from './store/exchangeConfigStore.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,
-    reconnectionDelay: 1000,
-    reconnectionDelayMax: 5000,
-  });
-
-  const errorCount = { count: 0 };
-
-  // User-registered event callbacks
-  const callbacks = {};
-
-  function emit(event, data) {
-    if (callbacks[event]) {
-      callbacks[event].forEach((cb) => {
-        try { cb(data); } catch (e) { console.error(`Error in ${event} callback:`, e.message); }
-      });
-    }
-  }
-
-  const heartbeatInterval = setInterval(() => {
-    if (socket.connected) {
-      socket.emit('ping');
-    }
-  }, 30000);
-
-  socket.on('connect', () => {
-    socket.emit('join_public');
-    socket.emit('join_private');
-    errorCount.count = 0;
-    emit('connect', null);
-  });
-
-  socket.on('connect_error', (err) => {
-    console.log('Socket connect error:', err.message);
-    errorCount.count += 1;
-    if (errorCount.count >= 3) {
-      resetPools();
-      resetCoins();
-      resetChains();
-      resetWallets();
-      resetUserShares();
-      resetOrderBooks();
-      resetMarkets();
-    }
-    emit('connect_error', err);
-  });
-
-  socket.on('disconnect', (reason) => {
-    console.log('Disconnected from Socket.IO server:', reason);
-    clearInterval(heartbeatInterval);
-    resetPools();
-    resetCoins();
-    resetChains();
-    resetWallets();
-    resetUserShares();
-    resetMarkets();
-    emit('disconnect', reason);
-  });
-
-  socket.io.on('reconnect_attempt', (attempt) => {
-    console.log(`Reconnect attempt #${attempt}`);
-    emit('reconnect_attempt', attempt);
-  });
-
-  socket.io.on('reconnect', () => {
-    emit('reconnect', null);
-  });
-
-  socket.io.on('reconnect_error', (err) => {
-    console.log('Reconnect error:', err.message);
-    errorCount.count += 1;
-    if (errorCount.count >= 3) {
-      resetPools();
-      resetCoins();
-      resetChains();
-      resetWallets();
-      resetUserShares();
-      resetOrderBooks();
-    }
-    emit('reconnect_error', err);
-  });
-
-  socket.on('error', (err) => {
-    console.log('Socket error:', err.message);
-    emit('error', err);
-  });
-
-  // ---- Public room events ----
-
-  socket.on('exchange_config', (config) => {
-    setExchangeConfig(config);
-    emit('exchange_config', config);
+// ---- Shared public event handler registration ----
+// Used by both setupSocket and setupPublicSocket to avoid duplicating handler code.
+function _registerPublicHandlers(socket, emit) {
+  socket.on('exchange_config', (cfg) => {
+    setExchangeConfig(cfg);
+    emit('exchange_config', cfg);
   });
 
   socket.on('markets_initial', (data) => {
@@ -204,6 +113,102 @@ export function setupSocket(config) {
   socket.on('candlestick_updated', (data) => {
     emit('candlestick_updated', data);
   });
+}
+
+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,
+    reconnectionDelay: 1000,
+    reconnectionDelayMax: 5000,
+  });
+
+  const errorCount = { count: 0 };
+
+  // User-registered event callbacks
+  const callbacks = {};
+
+  function emit(event, data) {
+    if (callbacks[event]) {
+      callbacks[event].forEach((cb) => {
+        try { cb(data); } catch (e) { console.error(`Error in ${event} callback:`, e.message); }
+      });
+    }
+  }
+
+  const heartbeatInterval = setInterval(() => {
+    if (socket.connected) {
+      socket.emit('ping');
+    }
+  }, 30000);
+
+  socket.on('connect', () => {
+    socket.emit('join_public');
+    socket.emit('join_private');
+    errorCount.count = 0;
+    emit('connect', null);
+  });
+
+  socket.on('connect_error', (err) => {
+    console.log('Socket connect error:', err.message);
+    errorCount.count += 1;
+    if (errorCount.count >= 3) {
+      resetPools();
+      resetCoins();
+      resetChains();
+      resetWallets();
+      resetUserShares();
+      resetOrderBooks();
+      resetMarkets();
+    }
+    emit('connect_error', err);
+  });
+
+  socket.on('disconnect', (reason) => {
+    console.log('Disconnected from Socket.IO server:', reason);
+    clearInterval(heartbeatInterval);
+    resetPools();
+    resetCoins();
+    resetChains();
+    resetWallets();
+    resetUserShares();
+    resetMarkets();
+    emit('disconnect', reason);
+  });
+
+  socket.io.on('reconnect_attempt', (attempt) => {
+    console.log(`Reconnect attempt #${attempt}`);
+    emit('reconnect_attempt', attempt);
+  });
+
+  socket.io.on('reconnect', () => {
+    emit('reconnect', null);
+  });
+
+  socket.io.on('reconnect_error', (err) => {
+    console.log('Reconnect error:', err.message);
+    errorCount.count += 1;
+    if (errorCount.count >= 3) {
+      resetPools();
+      resetCoins();
+      resetChains();
+      resetWallets();
+      resetUserShares();
+      resetOrderBooks();
+    }
+    emit('reconnect_error', err);
+  });
+
+  socket.on('error', (err) => {
+    console.log('Socket error:', err.message);
+    emit('error', err);
+  });
+
+  // ---- Public room events (shared handler) ----
+  _registerPublicHandlers(socket, emit);
 
   // ---- Private room events ----
 
@@ -303,12 +308,12 @@ export function setupSocket(config) {
     }
   }
 
-  function joinCandlesticks(poolId, timeframe) {
-    socket.emit('join_candlesticks', { poolId, timeframe });
+  function joinCandlesticks(pair, timeframe) {
+    socket.emit('join_candlesticks', { pair, timeframe });
   }
 
-  function leaveCandlesticks(poolId, timeframe) {
-    socket.emit('leave_candlesticks', { poolId, timeframe });
+  function leaveCandlesticks(pair, timeframe) {
+    socket.emit('leave_candlesticks', { pair, timeframe });
   }
 
   function sendYardMessage(text) {
@@ -344,3 +349,144 @@ export function setupSocket(config) {
     leavePrivate,
   };
 }
+
+// ---- Public-only socket (no auth) ----
+
+const _storeResetMap = {
+  pools: resetPools,
+  coins: resetCoins,
+  chains: resetChains,
+  orderbooks: resetOrderBooks,
+  markets: resetMarkets,
+};
+
+export function setupPublicSocket(config, requestedStores) {
+  const _requestedStores = new Set(requestedStores);
+
+  const socket = io(config.socketUrl, {
+    transports: ['websocket'],
+    reconnection: true,
+    reconnectionAttempts: Infinity,
+    reconnectionDelay: 1000,
+    reconnectionDelayMax: 5000,
+  });
+
+  const errorCount = { count: 0 };
+
+  // User-registered event callbacks
+  const callbacks = {};
+
+  function emit(event, data) {
+    if (callbacks[event]) {
+      callbacks[event].forEach((cb) => {
+        try { cb(data); } catch (e) { console.error(`Error in ${event} callback:`, e.message); }
+      });
+    }
+  }
+
+  const heartbeatInterval = setInterval(() => {
+    if (socket.connected) {
+      socket.emit('ping');
+    }
+  }, 30000);
+
+  socket.on('connect', () => {
+    socket.emit('join_public_selective', { stores: [..._requestedStores] });
+    errorCount.count = 0;
+    emit('connect', null);
+  });
+
+  socket.on('connect_error', (err) => {
+    console.log('Socket connect error:', err.message);
+    errorCount.count += 1;
+    if (errorCount.count >= 3) {
+      for (const store of _requestedStores) {
+        if (_storeResetMap[store]) { _storeResetMap[store](); }
+      }
+    }
+    emit('connect_error', err);
+  });
+
+  socket.on('disconnect', (reason) => {
+    console.log('Disconnected from Socket.IO server:', reason);
+    clearInterval(heartbeatInterval);
+    for (const store of _requestedStores) {
+      if (_storeResetMap[store]) { _storeResetMap[store](); }
+    }
+    emit('disconnect', reason);
+  });
+
+  socket.io.on('reconnect_attempt', (attempt) => {
+    console.log(`Reconnect attempt #${attempt}`);
+    emit('reconnect_attempt', attempt);
+  });
+
+  socket.io.on('reconnect', () => {
+    emit('reconnect', null);
+  });
+
+  socket.io.on('reconnect_error', (err) => {
+    console.log('Reconnect error:', err.message);
+    errorCount.count += 1;
+    if (errorCount.count >= 3) {
+      for (const store of _requestedStores) {
+        if (_storeResetMap[store]) { _storeResetMap[store](); }
+      }
+    }
+    emit('reconnect_error', err);
+  });
+
+  socket.on('error', (err) => {
+    console.log('Socket error:', err.message);
+    emit('error', err);
+  });
+
+  // ---- Public room events (shared handler) ----
+  _registerPublicHandlers(socket, emit);
+
+  socket.on('pong', () => {
+    emit('pong', null);
+  });
+
+  // ---- Convenience methods ----
+
+  function on(event, callback) {
+    if (!callbacks[event]) {
+      callbacks[event] = [];
+    }
+    callbacks[event].push(callback);
+  }
+
+  function off(event, callback) {
+    if (!callbacks[event]) { return; }
+    if (callback) {
+      callbacks[event] = callbacks[event].filter((cb) => cb !== callback);
+    } else {
+      delete callbacks[event];
+    }
+  }
+
+  function requestStores(additionalStores) {
+    for (const store of additionalStores) {
+      _requestedStores.add(store);
+    }
+    socket.emit('request_stores', { stores: additionalStores });
+  }
+
+  function joinCandlesticks(pair, timeframe) {
+    socket.emit('join_candlesticks', { pair, timeframe });
+  }
+
+  function leaveCandlesticks(pair, timeframe) {
+    socket.emit('leave_candlesticks', { pair, timeframe });
+  }
+
+  return {
+    socket,
+    on,
+    off,
+    requestStores,
+    joinCandlesticks,
+    leaveCandlesticks,
+  };
+}

package/src/waitForStores.mjs

@@ -4,6 +4,7 @@ import { chainStore, getChains } from './store/chainStore.mjs';
 import { walletStore, getWallets } from './store/walletStore.mjs';
 import { userSharesStore, getUserShares } from './store/userSharesStore.mjs';
 import { orderbookStore, getAllOrderBooks } from './store/orderbookStore.mjs';
+import { getMarkets } from './store/marketStore.mjs';
 
 export function waitForStores(socket) {
   // Function to wait for poolStore to be populated
@@ -224,4 +225,84 @@ export function waitForStores(socket) {
       userShares,
       orderbooks,
     }));
+}
+
+// ---- Selective store waiting (for public-only initialization) ----
+
+const _storeDefinitions = {
+  pools: {
+    waitEvent: 'pools_updated',
+    checkReady: () => poolStore.isInitialReceived,
+    getData: getPools,
+  },
+  coins: {
+    waitEvent: 'coins_updated',
+    checkReady: () => coinStore.isInitialReceived,
+    getData: getCoins,
+  },
+  chains: {
+    waitEvent: 'chains_updated',
+    checkReady: () => chainStore.isInitialReceived,
+    getData: getChains,
+  },
+  orderbooks: {
+    waitEvent: 'orderbooks_initial',
+    checkReady: () => orderbookStore.isInitialReceived,
+    getData: getAllOrderBooks,
+  },
+  markets: {
+    waitEvent: 'markets_initial',
+    checkReady: () => true, // fire-and-forget, resolve immediately
+    getData: getMarkets,
+  },
+};
+
+export function waitForSelectiveStores(socket, requestedStores) {
+  const promises = [];
+
+  for (const storeName of requestedStores) {
+    const def = _storeDefinitions[storeName];
+    if (!def) {
+      // Stores not in the map (buckets, operations, messages, status) are silently skipped
+      continue;
+    }
+
+    const promise = new Promise((resolve, reject) => {
+      if (def.checkReady()) {
+        resolve({ [storeName]: def.getData() });
+        return;
+      }
+
+      const timeout = setTimeout(() => {
+        reject(new Error(`Timeout waiting for initial ${storeName} data`));
+      }, 30000);
+
+      const handler = (data) => {
+        const isInitial = data && data.isInitial;
+        if (isInitial) {
+          clearTimeout(timeout);
+          socket.off(def.waitEvent, handler);
+          resolve({ [storeName]: def.getData() });
+        }
+      };
+
+      socket.on(def.waitEvent, handler);
+
+      socket.on('connect_error', () => {
+        clearTimeout(timeout);
+        reject(new Error(`Socket connection failed while waiting for ${storeName}`));
+      });
+
+      socket.on('disconnect', () => {
+        clearTimeout(timeout);
+        reject(new Error(`Socket disconnected before receiving initial ${storeName} data`));
+      });
+    });
+
+    promises.push(promise);
+  }
+
+  return Promise.all(promises).then((results) => {
+    return Object.assign({}, ...results);
+  });
 }