En tant que développeur et analyste quantitatif qui échange des cryptomonnaies depuis 2019, j'ai passé des centaines d'heures à scruter les carnets d'ordres. La visualisation de la liquidité via une heatmap n'est pas qu'un exercice esthétique — c'est un outil de survie pour identifier les murs d'achat, les squeeze de liquidité et les opportunités d'arbitrage avant qu'il ne soit trop tard. Dans ce tutoriel, je vais vous montrer comment construire une Cryptocurrency Liquidity Heatmap professionnelle avec une latence inférieure à 50ms, le tout intégré à l'API HolySheep AI pour l'analyse intelligente des données.

Qu'est-ce qu'une Liquidity Heatmap ?

Une heatmap de liquidité est une représentation visuelle bidimensionnelle qui affiche le volume de liquidité disponible à chaque niveau de prix d'un actif financier. Contrairement à un simple graphique en chandeliers, la heatmap révèle la structure cachée du carnet d'ordres : les zones de fort soutien (walls d'achat), les zones de résistance massives, et les vides de liquidité où les prix peuvent se déplacer violemment.

Pour les traders de cryptomonnaies, cette visualisation est cruciale car :

Architecture Technique de Notre Solution

Notre stack technique repose sur trois piliers :

Comparatif des Coûts API pour l'Analyse de Marché

Avant de commencer, situons les coûts. Voici le comparatif des prix 2026 pour les principaux fournisseurs d'API d'analyse IA :

Modèle Prix par Million de Tokens Coût pour 10M tokens/mois Latence moyenne
GPT-4.1 8,00 $ 80,00 $ ~800ms
Claude Sonnet 4.5 15,00 $ 150,00 $ ~950ms
Gemini 2.5 Flash 2,50 $ 25,00 $ ~400ms
DeepSeek V3.2 0,42 $ 4,20 $ ~600ms
HolySheep AI (DeepSeek V3.2) 0,42 $ 4,20 $ <50ms

Économie réalisée avec HolySheep AI : 85% moins cher que l'API OpenAI, avec une latence 16x inférieure (moins de 50ms vs 800ms pour GPT-4.1).

Implémentation Complète

Installation et Configuration

# Installation des dépendances
npm install axios d3 ws holy-sheep-sdk


Structure du projet

mkdir liquidity-heatmap
cd liquidity-heatmap
touch index.html server.js config.js

Configuration de l'API HolySheep

// config.js
module.exports = {
  // === CONFIGURATION HOLYSHEEP AI ===
  // IMPORTANT: Utilisez uniquement l'endpoint HolySheep, jamais api.openai.com
  baseUrl: 'https://api.holysheep.ai/v1',
  apiKey: process.env.HOLYSHEEP_API_KEY || 'YOUR_HOLYSHEEP_API_KEY',
  
  // WebSocket endpoints pour données temps réel
  wsEndpoints: {
    binance: 'wss://stream.binance.com:9443/ws',
    coinbase: 'wss://ws-feed.exchange.coinbase.com'
  },
  
  // Paramètres de la heatmap
  heatmapConfig: {
    priceLevels: 50,        // Nombre de niveaux de prix affichés
    updateInterval: 100,    // ms entre chaque mise à jour
    colorScale: {
      bid: '#00ff88',       // Vert pour les achats (bids)
      ask: '#ff3366',       // Rouge pour les ventes (asks)
      neutral: '#1a1a2e'    // Fond sombre
    },
    // Analyse IA: actif ou désactivé
    enableAIAnalysis: true,
    aiModel: 'deepseek-v3.2' // Modèle économique et performant
  },
  
  // Seuils d'alerte liquidité
  alertThresholds: {
    wallSize: 100000,       // 100k USDT pour détecter un wall
    imbalanceRatio: 0.7,    // 70% de déséquilibre = signal fort
    vacuumDepth: 50000      // Seuil pour détecter un vide de liquidité
  }
};

Serveur Node.js avec WebSocket et Analyse IA

// server.js
const WebSocket = require('ws');
const axios = require('axios');
const config = require('./config');

class LiquidityAnalyzer {
  constructor() {
    this.orderBook = { bids: [], asks: [] };
    this.lastAIAnalysis = null;
    this.aiCache = new Map();
    this.cacheTimeout = 5000; // Cache AI analysis 5s
  }
  
  // === CONNEXION WEBSOCKET BINANCE ===
  connectBinanceWebSocket(symbol = 'btcusdt') {
    const ws = new WebSocket(${config.wsEndpoints.binance}/${symbol}@depth20@100ms);
    
    ws.on('message', (data) => {
      const message = JSON.parse(data);
      this.processOrderBookUpdate(message);
    });
    
    ws.on('error', (error) => {
      console.error('WebSocket Error:', error.message);
    });
    
    return ws;
  }
  
  processOrderBookUpdate(data) {
    // Mise à jour du carnet d'ordres
    this.orderBook.bids = data.bids.map(([price, qty]) => ({
      price: parseFloat(price),
      quantity: parseFloat(qty),
      total: parseFloat(price) * parseFloat(qty)
    }));
    
    this.orderBook.asks = data.asks.map(([price, qty]) => ({
      price: parseFloat(price),
      quantity: parseFloat(qty),
      total: parseFloat(price) * parseFloat(qty)
    }));
  }
  
  // === ANALYSE HOLYSHEEP AI ===
  async analyzeLiquidityWithAI() {
    // Vérification du cache
    const cacheKey = this.getCacheKey();
    if (this.aiCache.has(cacheKey)) {
      const cached = this.aiCache.get(cacheKey);
      if (Date.now() - cached.timestamp < this.cacheTimeout) {
        return cached.data;
      }
    }
    
    try {
      // Préparation des données pour l'analyse
      const analysisData = {
        orderBookDepth: this.calculateDepth(),
        bidAskSpread: this.calculateSpread(),
        volumeImbalance: this.calculateImbalance(),
        detectedWalls: this.detectLiquidityWalls(),
        vacuumZones: this.detectVacuumZones()
      };
      
      // === APPEL HOLYSHEEP AI API ===
      // Prix: $0.42/MTok vs $8/MTok OpenAI (économie 95%)
      // Latence: <50ms vs 800ms
      const response = await axios.post(
        ${config.baseUrl}/chat/completions,
        {
          model: 'deepseek-v3.2',
          messages: [
            {
              role: 'system',
              content: 'Tu es un analyste expert en cryptomonnaies. Analyse le carnet d\'ordres et fournis des signaux de trading.'
            },
            {
              role: 'user',
              content: Analyse cette structure de liquidité BTC/USDT:\n${JSON.stringify(analysisData, null, 2)}
            }
          ],
          temperature: 0.3,
          max_tokens: 500
        },
        {
          headers: {
            'Authorization': Bearer ${config.apiKey},
            'Content-Type': 'application/json'
          }
        }
      );
      
      const analysis = response.data.choices[0].message.content;
      
      // Mise en cache
      this.aiCache.set(cacheKey, {
        data: analysis,
        timestamp: Date.now()
      });
      
      this.lastAIAnalysis = analysis;
      return analysis;
      
    } catch (error) {
      console.error('HolySheep AI Error:', error.response?.data || error.message);
      return null;
    }
  }
  
  // === CALCULS DE LIQUIDITÉ ===
  calculateDepth() {
    const bidDepth = this.orderBook.bids.reduce((sum, b) => sum + b.total, 0);
    const askDepth = this.orderBook.asks.reduce((sum, a) => sum + a.total, 0);
    return { bidDepth, askDepth, totalDepth: bidDepth + askDepth };
  }
  
  calculateSpread() {
    const bestBid = this.orderBook.bids[0]?.price || 0;
    const bestAsk = this.orderBook.asks[0]?.price || 0;
    return {
      absolute: bestAsk - bestBid,
      percentage: bestBid > 0 ? ((bestAsk - bestBid) / bestBid) * 100 : 0
    };
  }
  
  calculateImbalance() {
    const { bidDepth, askDepth } = this.calculateDepth();
    const total = bidDepth + askDepth;
    if (total === 0) return 0;
    return (bidDepth - askDepth) / total; // -1 à +1
  }
  
  detectLiquidityWalls() {
    const walls = [];
    const threshold = config.alertThresholds.wallSize;
    
    [...this.orderBook.bids, ...this.orderBook.asks].forEach(level => {
      if (level.total > threshold) {
        walls.push({
          price: level.price,
          volume: level.total,
          type: level.price < this.orderBook.bids[0]?.price ? 'bid' : 'ask'
        });
      }
    });
    
    return walls;
  }
  
  detectVacuumZones() {
    const vacuumZones = [];
    const threshold = config.alertThresholds.vacuumDepth;
    const priceRange = 0.01; // 1% de plage de prix
    
    for (let i = 1; i < this.orderBook.bids.length - 1; i++) {
      const current = this.orderBook.bids[i];
      const prev = this.orderBook.bids[i - 1];
      const next = this.orderBook.bids[i + 1];
      
      if (current.total < threshold && 
          Math.abs(current.price - prev.price) < priceRange * prev.price &&
          Math.abs(current.price - next.price) < priceRange * next.price) {
        vacuumZones.push({ price: current.price, volume: current.total });
      }
    }
    
    return vacuumZones;
  }
  
  getCacheKey() {
    const { bidDepth, askDepth } = this.calculateDepth();
    return ${bidDepth.toFixed(0)}-${askDepth.toFixed(0)};
  }
}

// === DÉMARRAGE DU SERVEUR ===
const analyzer = new LiquidityAnalyzer();
const ws = analyzer.connectBinanceWebSocket('btcusdt');

// Boucle d'analyse toutes les 2 secondes
setInterval(async () => {
  if (config.heatmapConfig.enableAIAnalysis) {
    const aiAnalysis = await analyzer.analyzeLiquidityWithAI();
    console.log('=== AI LIQUIDITY ANALYSIS ===');
    console.log(aiAnalysis);
    console.log('Imbalance:', (analyzer.calculateImbalance() * 100).toFixed(1) + '%');
    console.log('Walls detected:', analyzer.detectLiquidityWalls().length);
  }
  
  // Émission vers le client pour visualisation
  const heatmapData = {
    bids: analyzer.orderBook.bids.slice(0, 50),
    asks: analyzer.orderBook.asks.slice(0, 50),
    analysis: analyzer.lastAIAnalysis,
    timestamp: Date.now()
  };
  
  // Émettre via Socket.IO ou similaire (non inclus pour brevity)
}, 2000);

console.log('🚀 Liquidity Heatmap Server started');
console.log('📊 HolySheep AI: $0.42/MTok (vs $8 OpenAI)');
console.log('⚡ Latence: <50ms garantie');

Frontend : Visualisation D3.js de la Heatmap

<!-- index.html -->
<!DOCTYPE html>
<html lang="fr">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Crypto Liquidity Heatmap - HolySheep AI</title>
  <script src="https://d3js.org/d3.v7.min.js"></script>
  <style>
    * { margin: 0; padding: 0; box-sizing: border-box; }
    body { 
      background: #0d0d1a; 
      color: #e0e0e0; 
      font-family: 'Segoe UI', sans-serif;
      overflow: hidden;
    }
    .container { display: flex; height: 100vh; }
    .heatmap-panel { flex: 2; position: relative; }
    .ai-panel { 
      flex: 1; 
      background: #1a1a2e; 
      padding: 20px;
      border-left: 2px solid #00ff88;
      overflow-y: auto;
    }
    h1 { 
      color: #00ff88; 
      padding: 20px; 
      font-size: 24px;
      border-bottom: 1px solid #333;
    }
    .stats {
      display: grid;
      grid-template-columns: repeat(3, 1fr);
      gap: 15px;
      padding: 15px;
      background: #1a1a2e;
    }
    .stat-box {
      background: #252540;
      padding: 15px;
      border-radius: 8px;
      text-align: center;
    }
    .stat-value { font-size: 24px; font-weight: bold; color: #00ff88; }
    .stat-label { font-size: 12px; color: #888; margin-top: 5px; }
    .ai-analysis {
      background: #1a1a2e;
      border-radius: 10px;
      padding: 20px;
      margin-top: 20px;
      border: 1px solid #333;
    }
    .ai-analysis h3 { color: #00ff88; margin-bottom: 15px; }
    .signal { 
      padding: 10px; 
      margin: 10px 0; 
      border-radius: 5px;
      font-size: 14px;
    }
    .signal.bullish { background: rgba(0, 255, 136, 0.2); border-left: 3px solid #00ff88; }
    .signal.bearish { background: rgba(255, 51, 102, 0.2); border-left: 3px solid #ff3366; }
    .signal.neutral { background: rgba(255, 255, 255, 0.1); border-left: 3px solid #888; }
    .legend {
      display: flex;
      gap: 20px;
      padding: 15px;
      background: #1a1a2e;
    }
    .legend-item { display: flex; align-items: center; gap: 8px; }
    .legend-color {
      width: 20px;
      height: 20px;
      border-radius: 3px;
    }
    .legend-color.bid { background: #00ff88; }
    .legend-color.ask { background: #ff3366; }
    .legend-color.vacuum { background: #ffaa00; }
  </style>
</head>
<body>
  <h1>📊 Cryptocurrency Liquidity Heatmap — powered by <a href='https://www.holysheep.ai/register' style='color:#00ff88;'>HolySheep AI</a></h1>
  
  <div class="stats">
    <div class="stat-box">
      <div class="stat-value" id="bidDepth">0</div>
      <div class="stat-label">Volume Achat (USDT)</div>
    </div>
    <div class="stat-box">
      <div class="stat-value" id="askDepth">0</div>
      <div class="stat-label">Volume Vente (USDT)</div>
    </div>
    <div class="stat-box">
      <div class="stat-value" id="imbalance">0%</div>
      <div class="stat-label">Déséquilibre</div>
    </div>
  </div>
  
  <div class="legend">
    <div class="legend-item"><div class="legend-color bid"></div><span>Murs d'Achat (Bids)</span></div>
    <div class="legend-item"><div class="legend-color ask"></div><span>Murs de Vente (Asks)</span></div>
    <div class="legend-item"><div class="legend-color vacuum"></div><span>Zones de Vide</span></div>
  </div>
  
  <div class="container">
    <div class="heatmap-panel">
      <svg id="heatmap"></svg>
    </div>
    <div class="ai-panel">
      <h2>🤖 Analyse HolySheep AI</h2>
      <p style="color:#888;margin:10px 0;">$0.42/MTok · <50ms latence</p>
      <div class="ai-analysis">
        <h3>Signaux de Trading</h3>
        <div id="signals"></div>
        <div id="aiAnalysis" style="margin-top:20px;line-height:1.6;"></div>
      </div>
    </div>
  </div>

  <script>
    const margin = { top: 20, right: 50, bottom: 30, left: 80 };
    const width = window.innerWidth * 0.65 - margin.left - margin.right;
    const height = window.innerHeight - 200 - margin.top - margin.bottom;
    
    const svg = d3.select('#heatmap')
      .attr('width', width + margin.left + margin.right)
      .attr('height', height + margin.top + margin.bottom)
      .append('g')
      .attr('transform', translate(${margin.left},${margin.top}));
    
    const xScale = d3.scaleLinear().range([0, width]);
    const yScale = d3.scaleBand().range([0, height]).padding(0.02);
    
    function renderHeatmap(data) {
      const allPrices = [...data.bids.map(b => b.price), ...data.asks.map(a => a.price)];
      const maxVolume = Math.max(
        ...data.bids.map(b => b.total),
        ...data.asks.map(a => a.total)
      );
      
      xScale.domain([0, maxVolume]);
      yScale.domain(allPrices);
      
      // Rendu des bids (verts)
      svg.selectAll('.cell-bid')
        .data(data.bids, d => d.price)
        .join('rect')
        .attr('class', 'cell-bid')
        .attr('x', 0)
        .attr('y', d => yScale(d.price))
        .attr('width', d => xScale(d.total))
        .attr('height', yScale.bandwidth())
        .attr('fill', d => d3.interpolateGreens(0.3 + (d.total / maxVolume) * 0.7))
        .attr('opacity', 0.8);
      
      // Rendu des asks (rougs)
      svg.selectAll('.cell-ask')
        .data(data.asks, d => d.price)
        .join('rect')
        .attr('class', 'cell-ask')
        .attr('x', width / 2)
        .attr('y', d => yScale(d.price))
        .attr('width', d => xScale(d.total))
        .attr('height', yScale.bandwidth())
        .attr('fill', d => d3.interpolateReds(0.3 + (d.total / maxVolume) * 0.7))
        .attr('opacity', 0.8);
      
      // Ligne centrale (prix actuel)
      svg.append('line')
        .attr('x1', width / 2)
        .attr('x2', width / 2)
        .attr('y1', 0)
        .attr('y2', height)
        .attr('stroke', '#fff')
        .attr('stroke-width', 2)
        .attr('stroke-dasharray', '5,5');
      
      // Axes
      svg.append('g')
        .attr('transform', translate(0,${height}))
        .call(d3.axisBottom(xScale).ticks(5).tickFormat(d => (d / 1000).toFixed(0) + 'k'));
      
      svg.append('g')
        .call(d3.axisLeft(yScale).tickFormat(d => d.toLocaleString()));
    }
    
    // WebSocket pour données temps réel
    const ws = new WebSocket('ws://localhost:8080');
    ws.onmessage = (event) => {
      const data = JSON.parse(event.data);
      renderHeatmap(data);
      
      // Mise à jour des stats
      const bidDepth = data.bids.reduce((s, b) => s + b.total, 0);
      const askDepth = data.asks.reduce((s, a) => s + a.total, 0);
      document.getElementById('bidDepth').textContent = (bidDepth / 1000).toFixed(0) + 'k';
      document.getElementById('askDepth').textContent = (askDepth / 1000).toFixed(0) + 'k';
      document.getElementById('imbalance').textContent = ((bidDepth - askDepth) / (bidDepth + askDepth) * 100).toFixed(1) + '%';
      
      if (data.analysis) {
        document.getElementById('aiAnalysis').innerHTML = data.analysis;
      }
    };
    
    // Simulation de données (si serveur non démarré)
    const mockData = {
      bids: Array.from({length: 50}, (_, i) => ({
        price: 65000 - i * 10,
        total: Math.random() * 50000 + 5000
      })),
      asks: Array.from({length: 50}, (_, i) => ({
        price: 65100 + i * 10,
        total: Math.random() * 50000 + 5000
      }))
    };
    renderHeatmap(mockData);
  </script>
</body>
</html>

Pour qui / Pour qui ce n'est pas fait

✅ Idéal pour ❌ Pas adapté pour
Traders intraday et scalpers qui doivent identifier les murs de liquidité en temps réel Investisseurs long-term qui n'ont pas besoin de données tick-by-tick
Développeurs de bots de trading automatisés Personnes sans connaissances en programmation (utilisez plutôt des outils graphiques)
Analystes quantitatifs construisant des modèles de market making Ceux qui cherchent des signaux de trading sans comprendre la microstructure du marché
Projets DeFi needing à visualizer la liquidité des pools Traders émotionnels qui prendront des décisions impulsives basées sur la heatmap
Chercheurs étudiant l'impact des ordres importants sur les prix Utilisateurs avec une connexion internet instable (<10 Mbps)

Tarification et ROI

Analysons le retour sur investissement de notre solution par rapport aux alternatives.

Solution Coût API/mois (10M tokens) Latence Coût infrastructure Coût total/mois
HolySheep AI + serveur propio 4,20 $ (DeepSeek V3.2) <50ms ~20 $ (VPS 4vCPU) ~24 $/mois
OpenAI GPT-4.1 80,00 $ ~800ms ~20 $ ~100 $/mois
Anthropic Claude 4.5 150,00 $ ~950ms ~20 $ ~170 $/mois
Solutions SaaS toutes faites Inclus Variable 0 $ 49-299 $/mois

Économie annuelle avec HolySheep AI : Jusqu'à 1 752 $ par rapport à Claude, et 912 $ par rapport à GPT-4.1. La latence 16x inférieure se traduit également par des décisions de trading plus rapides et plus pertinentes.

Erreurs courantes et solutions

Erreur 1 : "401 Unauthorized" ou "Invalid API Key"

Symptôme : La console affiche {"error":{"message":"Invalid API key provided"}}`

// ❌ MAUVAIS - Clé invalide ou malformée
const response = await axios.post(
  ${config.baseUrl}/chat/completions,
  { /* ... */ },
  {
    headers: {
      'Authorization': 'Bearer undefined', // Clé non définie
      // ou
      'Authorization': 'Bearer sk-wrong-key-format'
    }
  }
);

// ✅ CORRECT - Vérification et gestion d'erreur robuste
async function callHolySheepAPI(messages) {
  if (!config.apiKey || config.apiKey === 'YOUR_HOLYSHEEP_API_KEY') {
    throw new Error('HOLYSHEEP_API_KEY non configurée. Obtenez-la sur https://www.holysheep.ai/register');
  }
  
  try {
    const response = await axios.post(
      ${config.baseUrl}/chat/completions,
      {
        model: 'deepseek-v3.2',
        messages: messages,
        temperature: 0.3,
        max_tokens: 500
      },
      {
        headers: {
          'Authorization': Bearer ${config.apiKey},
          'Content-Type': 'application/json'
        },
        timeout: 10000 // Timeout 10s pour éviter les blocages
      }
    );
    return response.data;
  } catch (error) {
    if (error.response?.status === 401) {
      console.error('Clé API invalide. Vérifiez sur https://www.holysheep.ai/dashboard');
      throw new Error('AUTH_FAILED: Vérifiez votre clé API HolySheep');
    }
    throw error;
  }
}

Erreur 2 : Latence excessive (>500ms)

Symptôme : Les données de la heatmap arrivent avec un retard perceptible, les murs semblent "flottants".

// ❌ PROBLÈME - Pas d'optimisation, mise à jour trop fréquente
setInterval(async () => {
  const analysis = await callHolySheepAPI(data); // Latence 400ms
  // 400ms * 5 requêtes/seconde = 2 secondes CPU bloqué
}, 200);

// ✅ SOLUTION - Cache intelligent + debouncing
class OptimizedAnalyzer {
  constructor() {
    this.cache = new Map();
    this.cacheTTL = 5000; // 5 secondes
    this.pendingRequests = null;
  }
  
  async getAnalysis(data) {
    const cacheKey = this.hashData(data);
    const cached = this.cache.get(cacheKey);
    
    // Retourner le cache si valide
    if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
      return cached.result;
    }
    
    // Débouncer les requêtes simultanées
    if (!this.pendingRequests) {
      this.pendingRequests = this.executeRequest(data, cacheKey);
    }
    
    return this.pendingRequests;
  }
  
  async executeRequest(data, cacheKey) {
    try {
      const result = await callHolySheepAPI(data);
      this.cache.set(cacheKey, { result, timestamp: Date.now() });
      return result;
    } finally {
      this.pendingRequests = null;
    }
  }
  
  hashData(data) {
    // Simplification: utiliser les premiers chiffres significatifs
    return ${data.bids[0]?.price.toFixed(0)}_${data.asks[0]?.price.toFixed(0)};
  }
}

// Avec HolySheep: <50ms latence garantie vs 400ms+ chez OpenAI
// soit 8x plus rapide pour le même coût ($0.42/MTok)

Erreur 3 : WebSocket déconnecté et reconstitution du carnet

Symptôme : La heatmap se fige, les données sont obsolètes.

// ❌ NAIF - Pas de reconnexion
const ws = new WebSocket('wss://stream.binance.com:9443/ws/btcusdt@depth20');
ws.onclose = () => console.log('Déconnecté...');

// ✅ ROBUSTE - Reconnexion automatique avec backoff exponentiel
class ResilientWebSocket {
  constructor(url) {
    this.url = url;
    this.reconnectAttempts = 0;
    this.maxReconnectDelay = 30000;
    this.connect();
  }
  
  connect() {
    this.ws = new WebSocket(this.url);
    
    this.ws.onopen = () => {
      console.log('✅ WebSocket connecté');
      this.reconnectAttempts = 0;
      // Resubscribe aux channels
      this.ws.send(JSON.stringify({
        method: 'SUBSCRIBE',
        params: ['btcusdt@depth20@100ms'],
        id: 1
      }));
    };
    
    this.ws.onclose = () => {
      console.log('⚠️ WebSocket fermé, reconnexion...');
      this.scheduleReconnect();
    };
    
    this.ws.onerror = (error) => {
      console.error('❌ Erreur WebSocket:', error);
    };
    
    this.ws.onmessage = (event) => {
      const data = JSON.parse(event.data);
      this.onMessage(data);
    };
  }
  
  scheduleReconnect() {
    // Backoff exponentiel: 1s, 2s, 4s, 8s... max 30s
    const delay = Math.min(
      1000 * Math.pow(2, this.reconnectAttempts),
      this.maxReconnectDelay
    );
    
    console.log(Reconnexion dans ${delay}ms...);
    setTimeout(() => {
      this.reconnectAttempts++;
      this.connect();
    }, delay);
  }
  
  onMessage(data) {
    // Implémentez le traitement ici
    this.emit('data', data);
  }
  
  on(event, callback) {
    this.events = this.events || {};
    this.events[event] = callback;
  }
  
  emit(event, data) {
    if (this.events?.[event]) {
      this.events[event](data);
    }
  }
}

// Utilisation
const ws = new ResilientWebSocket('wss://stream.binance.com:9443/w

Ressources connexes
Articles connexes