@runesx/api-client 0.2.0 → 0.4.0

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,
@@ -16,12 +18,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) => {
@@ -30,212 +50,244 @@ export function setupSocket(config) {
     if (errorCount.count >= 3) {
       resetPools();
       resetCoins();
+      resetChains();
       resetWallets();
       resetUserShares();
     }
+    emit('connect_error', err);
   });
 
   socket.on('disconnect', (reason) => {
     console.log('Disconnected from Socket.IO server:', reason);
+    clearInterval(heartbeatInterval);
     resetPools();
     resetCoins();
+    resetChains();
     resetWallets();
     resetUserShares();
+    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();
-    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) {
       resetPools();
       resetCoins();
+      resetChains();
       resetWallets();
       resetUserShares();
     }
+    emit('reconnect_error', err);
   });
 
   socket.on('error', (err) => {
     console.log('Socket error:', err.message);
+    emit('error', err);
   });
 
+  // ---- Public room events ----
+
   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 }) => {
+    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('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, chainId, address, memo }) => {
-    // console.log('Deposit address generated:', { requestId, chainId, 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', (data) => {
+    emit('withdrawal_pin_generated', 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_queued', (data) => {
+    emit('withdrawal_queued', data);
   });
 
-  socket.on('withdrawal_queued', ({ pendingWithdrawalId, ticker }) => {
-    console.log('Withdrawal queued:', { pendingWithdrawalId, ticker });
+  socket.on('withdrawal_canceled', (data) => {
+    emit('withdrawal_canceled', data);
   });
 
-  socket.on('withdrawal_canceled', ({ ticker, amount }) => {
-    console.log('Withdrawal canceled:', { ticker, amount });
+  socket.on('withdrawal_updated', (data) => {
+    emit('withdrawal_updated', data);
   });
 
-  // socket.on('recent_yard_messages', (initialMessages) => {
-  //   console.log('Recent yard messages:', initialMessages);
-  // });
+  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();
-    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/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/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,
     }));