@runesx/api-client 0.3.0 → 0.4.0

package/src/socket.mjs

@@ -18,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) => {
@@ -36,32 +54,30 @@ export function setupSocket(config) {
       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();
-    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) {
@@ -71,187 +87,207 @@ export function setupSocket(config) {
       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 }) => {
-    // 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('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', (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);
-
-  socket.on('close', () => {
-    clearInterval(heartbeatInterval);
-    resetPools();
-    resetCoins();
-    resetChains();
-    resetWallets();
-    resetUserShares();
-  });
+  // ---- Convenience methods ----
 
-  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,
+  };
+}