@runesx/api-client 0.3.0 → 0.5.1

package/src/socket.mjs

@@ -6,6 +6,9 @@ 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';
+import { setInitialOrderBooks, updateOrderBook, resetOrderBooks, setUserOrders, updateUserOrder } from './store/orderbookStore.mjs';
+import { setInitialMarkets, addOrUpdateMarket, resetMarkets } from './store/marketStore.mjs';
+import { setExchangeConfig } from './store/exchangeConfigStore.mjs';
 
 export function setupSocket(config) {
   const socket = io(config.socketUrl, {
@@ -18,12 +21,30 @@ export function setupSocket(config) {
     reconnectionDelayMax: 5000,
   });
 
-  const errorCount = { count: 0 }; // Track connection errors
+  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) => {
@@ -35,33 +56,34 @@ export function setupSocket(config) {
       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.on('reconnect_attempt', (attempt) => {
+  socket.io.on('reconnect_attempt', (attempt) => {
     console.log(`Reconnect attempt #${attempt}`);
+    emit('reconnect_attempt', attempt);
   });
 
-  socket.on('reconnect', () => {
-    socket.emit('join_public');
-    socket.emit('join_private');
-    resetPools();
-    resetCoins();
-    resetChains();
-    resetWallets();
-    resetUserShares();
+  socket.io.on('reconnect', () => {
+    emit('reconnect', null);
   });
 
-  socket.on('reconnect_error', (err) => {
+  socket.io.on('reconnect_error', (err) => {
     console.log('Reconnect error:', err.message);
     errorCount.count += 1;
     if (errorCount.count >= 3) {
@@ -70,188 +92,255 @@ export function setupSocket(config) {
       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);
+  });
+
+  socket.on('markets_initial', (data) => {
+    setInitialMarkets(data);
+    emit('markets_initial', data);
+  });
+
+  socket.on('market_created', (data) => {
+    addOrUpdateMarket(data);
+    emit('market_created', data);
+  });
+
+  socket.on('market_updated', (data) => {
+    addOrUpdateMarket(data);
+    emit('market_updated', data);
   });
 
   socket.on('pools_updated', ({ pools, isInitial }) => {
-    // console.log('Received pools_updated:', { pools, isInitial });
     if (isInitial) {
       setInitialPools(pools);
     } else {
       pools.forEach(pool => updatePool(pool));
     }
+    emit('pools_updated', { pools, isInitial });
   });
 
   socket.on('coins_updated', ({ coins, isInitial }) => {
-    // console.log('Received coins_updated:', { coins, isInitial });
     if (isInitial) {
       setInitialCoins(coins);
     } else {
       coins.forEach(coin => updateCoin(coin));
     }
+    emit('coins_updated', { coins, isInitial });
   });
 
   socket.on('chains_updated', ({ chains, isInitial }) => {
-    // console.log('Received chains_updated:', { chains, isInitial });
     if (isInitial) {
       setInitialChains(chains);
     } else {
       chains.forEach(chain => updateChain(chain));
     }
+    emit('chains_updated', { chains, isInitial });
+  });
+
+  socket.on('buckets_updated', (data) => {
+    emit('buckets_updated', data);
+  });
+
+  socket.on('operations_updated', (operations) => {
+    emit('operations_updated', operations);
+  });
+
+  socket.on('recent_yard_messages', (data) => {
+    emit('recent_yard_messages', data);
+  });
+
+  socket.on('status_updated', (data) => {
+    emit('status_updated', data);
+  });
+
+  socket.on('orderbooks_initial', ({ books, isInitial }) => {
+    if (isInitial) {
+      setInitialOrderBooks(books);
+    }
+    emit('orderbooks_initial', { books, isInitial });
+  });
+
+  socket.on('orderbook_updated', ({ pair, bids, asks }) => {
+    updateOrderBook(pair, bids, asks);
+    emit('orderbook_updated', { pair, bids, asks });
+  });
+
+  socket.on('user_orders_initial', (orders) => {
+    setUserOrders(orders);
+    emit('user_orders_initial', orders);
   });
 
+  socket.on('order_updated', (data) => {
+    updateUserOrder(data);
+    emit('order_updated', data);
+  });
+
+  socket.on('clob_trade', (trade) => {
+    emit('clob_trade', trade);
+  });
+
+  socket.on('volumeUpdate', (data) => {
+    emit('volumeUpdate', data);
+  });
+
+  socket.on('operationUpdate', (operation) => {
+    emit('operationUpdate', operation);
+  });
+
+  socket.on('candlestick_updated', (data) => {
+    emit('candlestick_updated', data);
+  });
+
+  // ---- Private room events ----
+
   socket.on('wallets_updated', ({ wallets, isInitial }) => {
-    // console.log('Received wallets_updated:', { wallets, isInitial });
     if (isInitial) {
       setInitialWallets(wallets);
     } else {
       wallets.forEach(wallet => updateWallet(wallet));
     }
+    emit('wallets_updated', { wallets, isInitial });
   });
 
   socket.on('user_shares_updated', ({ userShares, isInitial }) => {
-    // console.log('Received user_shares_updated:', { userShares, isInitial });
     if (isInitial) {
       setInitialUserShares(userShares);
     } else {
       userShares.forEach(share => updateUserShare(share));
     }
+    emit('user_shares_updated', { userShares, isInitial });
   });
 
-  socket.on('volumeUpdate', ({ type, poolId, timestamp, volume }) => {
-    // console.log('Volume update:', { type, poolId, timestamp, volume });
-  });
-
-  socket.on('operationUpdate', (operation) => {
-    // console.log('Operation update:', operation);
-    // Assuming operation includes liquidity deposit/withdraw results
-    // if (operation.type === 'liquidity_deposit' || operation.type === 'liquidity_withdraw') {
-    //   console.log(`Liquidity operation ${operation.type} completed:`, {
-    //     uid: operation.uid,
-    //     coinA: operation.coinA,
-    //     coinB: operation.coinB,
-    //     amountA: operation.amountA,
-    //     amountB: operation.amountB,
-    //     shares: operation.shares,
-    //     status: operation.status,
-    //   });
-    // }
-  });
-  socket.on('status_updated', (data) => {
-    // console.log('Status update:', data);
-  });
-
-  socket.on('deposit_address_generated', ({ requestId, chainName, address, memo }) => {
-    // console.log('Deposit address generated:', { requestId, chainName, address, memo });
+  socket.on('deposit_address_generated', (data) => {
+    emit('deposit_address_generated', data);
   });
 
   socket.on('deposit_processed', (data) => {
-    const { amount, coin, chain, confirmations, status, credited } = data;
-    const message =
-      status === 'confirmed' && credited
-        ? `Deposit of ${amount} ${coin.ticker} confirmed!`
-        : `Deposit of ${amount} ${coin.ticker} (confirming) [${confirmations}/${chain.requiredConfirmations}]`;
-    console.log('Deposit processed:', { message, data });
+    emit('deposit_processed', data);
   });
 
   socket.on('withdrawal_processed', (data) => {
-    const { amount, coin, chain, confirmations, status, credited, createdAt } = data;
-    let message;
-    if (!createdAt) {
-      message = `Withdrawal of ${amount} ${coin.ticker} is stalled due to network congestion.`;
-    } else if (status === 'confirmed' && credited) {
-      message = `Withdrawal of ${amount} ${coin.ticker} confirmed!`;
-    } else {
-      message = `Withdrawal of ${amount} ${coin.ticker} (confirming) [${confirmations}/${chain.requiredConfirmations}]`;
-    }
-    console.log('Withdrawal processed:', { message, data });
+    emit('withdrawal_processed', data);
   });
 
   socket.on('withdrawal_initiated', (data) => {
-    console.log('Withdrawal initiated:', data);
+    emit('withdrawal_initiated', data);
   });
 
-  socket.on('withdrawal_pin_generated', ({ pinImage, ticker, amount, pendingWithdrawalId, expiresAt, dp, fee, memoRequired }) => {
-    console.log('Withdrawal pin generated:', {
-      ticker,
-      amount,
-      pinImage,
-      pendingWithdrawalId,
-      expiresAt,
-      dp,
-      fee,
-      memoRequired,
-    });
+  socket.on('withdrawal_pin_generated', (data) => {
+    emit('withdrawal_pin_generated', data);
   });
 
-  socket.on('withdrawal_queued', ({ pendingWithdrawalId, ticker }) => {
-    console.log('Withdrawal queued:', { pendingWithdrawalId, ticker });
+  socket.on('withdrawal_queued', (data) => {
+    emit('withdrawal_queued', data);
   });
 
-  socket.on('withdrawal_canceled', ({ ticker, amount }) => {
-    console.log('Withdrawal canceled:', { ticker, amount });
+  socket.on('withdrawal_canceled', (data) => {
+    emit('withdrawal_canceled', data);
   });
 
-  // socket.on('recent_yard_messages', (initialMessages) => {
-  //   console.log('Recent yard messages:', initialMessages);
-  // });
+  socket.on('withdrawal_updated', (data) => {
+    emit('withdrawal_updated', data);
+  });
+
+  socket.on('withdrawal_expired', (data) => {
+    emit('withdrawal_expired', data);
+  });
 
   socket.on('yard_message', (message) => {
-    // console.log('New chat message:', {
-    //   username: message.username,
-    //   text: message.text,
-    //   role: message.role,
-    //   timestamp: new Date(message.timestamp).toLocaleString(),
-    // });
+    emit('yard_message', message);
   });
 
-  socket.on('message_deleted', ({ messageId }) => {
-    // console.log('Message deleted:', { messageId });
+  socket.on('message_deleted', (data) => {
+    emit('message_deleted', data);
   });
 
-  socket.on('banned', ({ reason, bannedUntil }) => {
-    // console.log('Banned from yard:', {
-    //   reason,
-    //   bannedUntil: new Date(bannedUntil).toLocaleString(),
-    // });
+  socket.on('banned', (data) => {
+    emit('banned', data);
   });
 
-  socket.on('withdrawal_updated', ({ pendingWithdrawalId, expiresAt, stage }) => {
-    // console.log('Withdrawal updated:', { pendingWithdrawalId, expiresAt, stage });
+  socket.on('yard_read_marked', (data) => {
+    emit('yard_read_marked', data);
   });
 
-  socket.on('withdrawal_expired', ({ pendingWithdrawalId, ticker, amount }) => {
-    // console.log('Withdrawal expired:', { pendingWithdrawalId, ticker, amount });
+  socket.on('session_expired', (data) => {
+    emit('session_expired', data);
   });
 
   socket.on('pong', () => {
-    console.log('Received pong from server');
+    emit('pong', null);
   });
 
-  const heartbeatInterval = setInterval(() => {
-    if (socket.connected) {
-      socket.emit('ping');
-    }
-  }, 30000);
+  // ---- Convenience methods ----
 
-  socket.on('close', () => {
-    clearInterval(heartbeatInterval);
-    resetPools();
-    resetCoins();
-    resetChains();
-    resetWallets();
-    resetUserShares();
-  });
-
-  socket.on('connect', () => {
-    // socket.emit('yard_message', {
-    //   text: 'Hello from RunesX API Key Example Bot!!',
-    // });
-  });
+  function on(event, callback) {
+    if (!callbacks[event]) {
+      callbacks[event] = [];
+    }
+    callbacks[event].push(callback);
+  }
 
-  return { socket };
-}
+  function off(event, callback) {
+    if (!callbacks[event]) { return; }
+    if (callback) {
+      callbacks[event] = callbacks[event].filter((cb) => cb !== callback);
+    } else {
+      delete callbacks[event];
+    }
+  }
+
+  function joinCandlesticks(poolId, timeframe) {
+    socket.emit('join_candlesticks', { poolId, timeframe });
+  }
+
+  function leaveCandlesticks(poolId, timeframe) {
+    socket.emit('leave_candlesticks', { poolId, timeframe });
+  }
+
+  function sendYardMessage(text) {
+    socket.emit('yard_message', { text });
+  }
+
+  function deleteMessage(messageId) {
+    socket.emit('delete_message', { messageId });
+  }
+
+  function markYardRead() {
+    socket.emit('mark_yard_read');
+  }
+
+  function leavePublic() {
+    socket.leave('public');
+  }
+
+  function leavePrivate() {
+    socket.leave('private');
+  }
+
+  return {
+    socket,
+    on,
+    off,
+    joinCandlesticks,
+    leaveCandlesticks,
+    sendYardMessage,
+    deleteMessage,
+    markYardRead,
+    leavePublic,
+    leavePrivate,
+  };
+}

package/src/store/coinStore.mjs

@@ -1,4 +1,4 @@
-import { BigNumber } from 'bignumber.js';
+import { SafeBigNumber as BigNumber } from '../utils/safeBigNumber.mjs';
 
 const coinStore = {
   coins: new Map(), // Store coin data by coin ID

package/src/store/exchangeConfigStore.mjs

@@ -0,0 +1,48 @@
+// src/store/exchangeConfigStore.mjs
+// Exchange configuration received from the backend via socket.
+// Keeps fee rates, depth limits, etc. in sync without hardcoding.
+
+const exchangeConfigStore = {
+  clobFees: {
+    takerFeeRate: '0.002', // sensible default until backend config arrives
+    makerFeeRate: '0.001',
+    maxFillBatch: 50,
+    maxFillTotal: 500,
+  },
+};
+
+const setExchangeConfig = (config) => {
+  const { clobFees } = config;
+  if (clobFees) {
+    if (clobFees.takerFeeRate !== null && clobFees.takerFeeRate !== undefined) {
+      exchangeConfigStore.clobFees.takerFeeRate = clobFees.takerFeeRate;
+    }
+    if (clobFees.makerFeeRate !== null && clobFees.makerFeeRate !== undefined) {
+      exchangeConfigStore.clobFees.makerFeeRate = clobFees.makerFeeRate;
+    }
+    if (clobFees.maxFillBatch !== null && clobFees.maxFillBatch !== undefined) {
+      exchangeConfigStore.clobFees.maxFillBatch = clobFees.maxFillBatch;
+    }
+    if (clobFees.maxFillTotal !== null && clobFees.maxFillTotal !== undefined) {
+      exchangeConfigStore.clobFees.maxFillTotal = clobFees.maxFillTotal;
+    }
+  }
+};
+
+const getClobFees = () => exchangeConfigStore.clobFees;
+
+const resetExchangeConfig = () => {
+  exchangeConfigStore.clobFees = {
+    takerFeeRate: '0.002',
+    makerFeeRate: '0.001',
+    maxFillBatch: 50,
+    maxFillTotal: 500,
+  };
+};
+
+export {
+  exchangeConfigStore,
+  setExchangeConfig,
+  getClobFees,
+  resetExchangeConfig,
+};

package/src/store/marketStore.mjs

@@ -0,0 +1,57 @@
+// src/store/marketStore.mjs
+// Stores admin-defined markets received from the backend via socket.
+// Markets define the canonical pair direction (e.g., "RUNES-DOG" not "DOG-RUNES").
+
+let markets = [];
+let byCoinKey = {};
+
+function buildCoinKey(coinIdA, coinIdB) {
+  return coinIdA < coinIdB ? `${coinIdA}|${coinIdB}` : `${coinIdB}|${coinIdA}`;
+}
+
+function rebuildLookup() {
+  const lookup = {};
+  for (const m of markets) {
+    const key = buildCoinKey(m.baseCoinId, m.quoteCoinId);
+    lookup[key] = m;
+  }
+  byCoinKey = lookup;
+}
+
+export function setInitialMarkets(list) {
+  markets = list || [];
+  rebuildLookup();
+}
+
+export function addOrUpdateMarket(market) {
+  const idx = markets.findIndex((m) => m.id === market.id);
+  if (idx >= 0) {
+    markets[idx] = { ...markets[idx], ...market };
+  } else {
+    markets.push(market);
+  }
+  rebuildLookup();
+}
+
+export function getMarkets() {
+  return markets;
+}
+
+export function getMarketByCoinKey() {
+  return byCoinKey;
+}
+
+/**
+ * Look up a market by two coin IDs (order-independent).
+ * @param {string} coinIdA
+ * @param {string} coinIdB
+ * @returns {Object|undefined}
+ */
+export function getMarketByCoins(coinIdA, coinIdB) {
+  return byCoinKey[buildCoinKey(coinIdA, coinIdB)];
+}
+
+export function resetMarkets() {
+  markets = [];
+  byCoinKey = {};
+}

package/src/store/orderbookStore.mjs

@@ -0,0 +1,99 @@
+const orderbookStore = {
+  books: new Map(), // pair -> { bids: [[price, qty], ...], asks: [[price, qty], ...] }
+  isInitialReceived: false,
+  pendingUpdates: [],
+  userOrders: [], // User's open CLOB orders (across all pairs)
+};
+
+// Initialize all order books with initial data
+const setInitialOrderBooks = (books) => {
+  orderbookStore.books.clear();
+  for (const [pair, depth] of Object.entries(books)) {
+    orderbookStore.books.set(pair, {
+      bids: depth.bids || [],
+      asks: depth.asks || [],
+    });
+  }
+  orderbookStore.isInitialReceived = true;
+
+  // Process buffered updates
+  if (orderbookStore.pendingUpdates.length > 0) {
+    orderbookStore.pendingUpdates.forEach(({ pair, bids, asks }) => {
+      updateOrderBook(pair, bids, asks);
+    });
+    orderbookStore.pendingUpdates = [];
+  }
+};
+
+// Update a single order book
+const updateOrderBook = (pair, bids, asks) => {
+  if (!orderbookStore.isInitialReceived) {
+    orderbookStore.pendingUpdates.push({ pair, bids, asks });
+    return;
+  }
+  orderbookStore.books.set(pair, {
+    bids: bids || [],
+    asks: asks || [],
+  });
+};
+
+// Get all order books as a plain object { [pair]: { bids, asks } }
+const getAllOrderBooks = () => {
+  const result = {};
+  for (const [pair, depth] of orderbookStore.books) {
+    result[pair] = depth;
+  }
+  return result;
+};
+
+// Get a specific order book by pair
+const getOrderBook = (pair) => {
+  return orderbookStore.books.get(pair) || { bids: [], asks: [] };
+};
+
+// Get all pairs with active order books
+const getOrderBookPairs = () => {
+  return [...orderbookStore.books.keys()];
+};
+
+// Set user's open orders (received on connect)
+const setUserOrders = (orders) => {
+  orderbookStore.userOrders = orders || [];
+};
+
+// Update a single user order (from order_updated event)
+const updateUserOrder = (data) => {
+  if (data.refresh) {return;} // caller should refetch
+  const order = data.order;
+  if (!order) {return;}
+  const idx = orderbookStore.userOrders.findIndex((o) => o.id === order.id);
+  if (idx >= 0) {
+    orderbookStore.userOrders[idx] = { ...orderbookStore.userOrders[idx], ...order };
+  } else {
+    orderbookStore.userOrders.unshift(order);
+  }
+};
+
+// Get user's open orders
+const getUserOrders = () => orderbookStore.userOrders;
+
+// Reset store on disconnect or error
+const resetOrderBooks = () => {
+  orderbookStore.books.clear();
+  orderbookStore.isInitialReceived = false;
+  orderbookStore.pendingUpdates = [];
+  orderbookStore.userOrders = [];
+};
+
+export {
+  orderbookStore,
+  setInitialOrderBooks,
+  updateOrderBook,
+  getAllOrderBooks,
+  getOrderBook,
+  getOrderBookPairs,
+  setUserOrders,
+  updateUserOrder,
+  getUserOrders,
+  resetOrderBooks,
+};

package/src/store/poolStore.mjs

@@ -1,4 +1,4 @@
-import { BigNumber } from 'bignumber.js';
+import { SafeBigNumber as BigNumber } from '../utils/safeBigNumber.mjs';
 
 const poolStore = {
   pools: new Map(), // Store pool data by pool ID

package/src/store/userSharesStore.mjs

@@ -1,5 +1,5 @@
 // src/store/userSharesStore.mjs
-import { BigNumber } from 'bignumber.js';
+import { SafeBigNumber as BigNumber } from '../utils/safeBigNumber.mjs';
 
 const userSharesStore = {
   userShares: new Map(),

package/src/store/walletStore.mjs

@@ -1,4 +1,4 @@
-import { BigNumber } from 'bignumber.js';
+import { SafeBigNumber as BigNumber } from '../utils/safeBigNumber.mjs';
 
 const walletStore = {
   wallets: new Map(), // Store wallet data by ticker