WebSocket Disconnects in Trading Bots: Reconnection That Actually Works

class WebSocketManager {
  private ws: WebSocket | null = null;
  private reconnectAttempts = 0;
  private maxReconnectAttempts = 10;
  private isIntentionallyClosed = false;
  
  async connect(url: string): Promise<void> {
    return new Promise((resolve, reject) => {
      this.ws = new WebSocket(url);
      
      this.ws.onopen = () => {
        console.log('[WS] Connected');
        this.reconnectAttempts = 0; // Reset on success
        resolve();
      };
      
      this.ws.onclose = (event) => {
        console.log(`[WS] Closed: code=${event.code}, reason=${event.reason}`);
        
        if (!this.isIntentionallyClosed) {
          this.scheduleReconnect(url);
        }
      };
      
      this.ws.onerror = (error) => {
        console.error('[WS] Error:', error);
        // onclose will fire after onerror, reconnect happens there
      };
      
      this.ws.onmessage = (event) => {
        this.handleMessage(JSON.parse(event.data));
      };
    });
  }
  
  private scheduleReconnect(url: string): void {
    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
      console.error('[WS] Max reconnect attempts reached');
      this.onMaxRetriesExceeded();
      return;
    }
    
    const delay = this.calculateBackoff(this.reconnectAttempts);
    this.reconnectAttempts++;
    
    console.log(`[WS] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
    
    setTimeout(() => this.connect(url), delay);
  }
  
  private calculateBackoff(attempt: number): number {
    // Exponential backoff: 1s, 2s, 4s, 8s... capped at 30s
    const base = 1000;
    const max = 30000;
    const delay = Math.min(base * Math.pow(2, attempt), max);
    
    // Add jitter (±20%) to prevent thundering herd
    const jitter = delay * 0.2 * (Math.random() * 2 - 1);
    return Math.floor(delay + jitter);
  }
  
  close(): void {
    this.isIntentionallyClosed = true;
    this.ws?.close();
  }
}

private handleClose(event: CloseEvent, url: string): void {
  switch (event.code) {
    case 1000:
    case 1001:
      // Server closed cleanly, reconnect fast
      setTimeout(() => this.connect(url), 100);
      break;
    
    case 1008:
      // Auth issue, refresh token first
      this.refreshAuth().then(() => this.connect(url));
      break;
    
    default:
      // Unknown or error, use backoff
      this.scheduleReconnect(url);
  }
}

interface ExchangeMessage {
  e: string;        // Event type
  E: number;        // Event time
  u?: number;       // Update ID / sequence number
  // ... other fields
}
 
class GapDetector {
  private lastSequence: number | null = null;
  private gapDetected = false;
  
  checkSequence(message: ExchangeMessage): void {
    if (message.u === undefined) return; // Not all messages have sequences
    
    if (this.lastSequence !== null) {
      const expected = this.lastSequence + 1;
      
      if (message.u > expected) {
        console.warn(`[Gap] Missed ${message.u - expected} messages`);
        this.gapDetected = true;
        this.onGapDetected(this.lastSequence, message.u);
      } else if (message.u < expected) {
        console.warn(`[Gap] Duplicate or out-of-order message`);
        // Usually safe to ignore, but log for debugging
      }
    }
    
    this.lastSequence = message.u;
  }
  
  reset(): void {
    this.lastSequence = null;
    this.gapDetected = false;
  }
  
  private onGapDetected(lastSeen: number, current: number): void {
    // Trigger state recovery
  }
}

class HeartbeatManager {
  private pingInterval: NodeJS.Timer | null = null;
  private lastPong: number = Date.now();
  private timeout = 30000; // 30 seconds without pong = stale
  
  start(ws: WebSocket, interval: number = 15000): void {
    this.pingInterval = setInterval(() => {
      if (Date.now() - this.lastPong > this.timeout) {
        console.warn('[Heartbeat] Connection stale, forcing reconnect');
        ws.close(4001, 'Heartbeat timeout');
        return;
      }
      
      ws.send(JSON.stringify({ op: 'ping' }));
    }, interval);
  }
  
  receivedPong(): void {
    this.lastPong = Date.now();
  }
  
  stop(): void {
    if (this.pingInterval) {
      clearInterval(this.pingInterval);
      this.pingInterval = null;
    }
  }
}

private handleMessage(data: any): void {
  // Binance style ping
  if (data.ping) {
    this.ws?.send(JSON.stringify({ pong: data.ping }));
    return;
  }
  
  // OKX style ping
  if (data === 'ping') {
    this.ws?.send('pong');
    return;
  }
  
  // Process actual message
  this.processMessage(data);
}

async function recoverStateAfterReconnect(
  exchange: Exchange,
  state: TradingState
): Promise<void> {
  console.log('[Recovery] Starting post-reconnect state recovery...');
  
  // 1. Fetch current open orders via REST
  const exchangeOrders = await exchange.fetchOpenOrders(state.symbol);
  
  // 2. Reconcile with local state
  for (const remote of exchangeOrders) {
    const local = state.findOrder(remote.clientOrderId);
    
    if (!local) {
      // Orphan: was created while disconnected
      console.log(`[Recovery] Adopting orphan order: ${remote.clientOrderId}`);
      await state.adoptOrder(remote);
    } else if (remote.filled > local.filled) {
      // Fill happened while disconnected
      console.log(`[Recovery] Backfilling: ${local.filled} → ${remote.filled}`);
      await state.processFill(remote.clientOrderId, remote.filled, remote.price);
    }
  }
  
  // 3. Check for orders that closed while disconnected
  for (const local of state.openOrders) {
    const remote = exchangeOrders.find(o => o.clientOrderId === local.clientOrderId);
    
    if (!remote) {
      // Order no longer open—check what happened
      const historical = await exchange.fetchOrder(local.clientOrderId);
      
      if (historical?.status === 'filled') {
        await state.processFill(local.clientOrderId, historical.filled, historical.price);
      } else if (historical?.status === 'canceled') {
        await state.removeOrder(local.clientOrderId);
      }
    }
  }
  
  // 4. Verify position
  const position = await exchange.fetchPosition(state.symbol);
  if (Math.abs(position.size - state.position.size) > 0.0001) {
    console.warn(`[Recovery] Position drift corrected: ${state.position.size} → ${position.size}`);
    state.position.size = position.size;
    state.position.entryPrice = position.entryPrice;
  }
  
  console.log('[Recovery] State recovery complete');
}

async function fullReconnectionSequence(
  wsManager: WebSocketManager,
  exchange: Exchange,
  state: TradingState,
  subscriptions: string[]
): Promise<void> {
  // 1. Reconnect WebSocket
  await wsManager.connect(exchange.wsUrl);
  
  // 2. Re-authenticate if required
  await wsManager.authenticate(exchange.apiKey, exchange.apiSecret);
  
  // 3. Recover state via REST (don't trust WS history)
  await recoverStateAfterReconnect(exchange, state);
  
  // 4. Resubscribe to channels
  for (const sub of subscriptions) {
    await wsManager.subscribe(sub);
  }
  
  // 5. Reset gap detector (new connection, new sequence)
  gapDetector.reset();
  
  console.log('[Reconnect] Full reconnection sequence complete');
}

// Binance listen key refresh
setInterval(async () => {
  await exchange.keepAliveListenKey(listenKey);
}, 30 * 60 * 1000); // Every 30 minutes

// ❌ Wrong: Assuming WS gives complete history
ws.onopen = () => {
  console.log('Connected, ready to trade');
  startTrading(); // Dangerous!
};
 
// ✅ Correct: Verify state after reconnect
ws.onopen = async () => {
  await recoverStateAfterReconnect(exchange, state);
  startTrading();
};

// ❌ Wrong: Instant reconnect
ws.onclose = () => ws.reconnect();
 
// ✅ Correct: Exponential backoff
ws.onclose = () => {
  const delay = calculateBackoff(attempts);
  setTimeout(() => ws.reconnect(), delay);
};

// ❌ Wrong: Treating all closes the same
ws.onclose = () => reconnect();
 
// ✅ Correct: Handle codes appropriately
ws.onclose = (event) => {
  if (event.code === 1008) {
    refreshAuth().then(reconnect);
  } else {
    reconnect();
  }
};