@icgio/icg-exchanges-wrapper 1.14.256 → 1.14.258

package/functions/get-exchanges-rates-market-history-ohlcv.js

@@ -4,7 +4,111 @@ const DEFAULT_ORDERBOOK_LEVEL = 50
 
 let first_time = {},
   exchange_pair_rates = {},
-  pair_exchange_rates = {}
+  pair_exchange_rates = {},
+  // Track active WebSocket connections per exchange to avoid duplicates
+  ws_connection_promises = {},
+  ws_connection_pairs = {},
+  // Track wrapped promises with fallback handlers to avoid duplicate handlers
+  ws_connection_promises_with_fallback = {},
+  // Track persistent WebSocket failures per pair to avoid repeated retries
+  ws_failed_pairs = {}, // { "ExchangeName": { "PAIR": { count: number, last_failed: timestamp } } }
+  WS_FAILURE_THRESHOLD = 3, // Skip WebSocket after 3 consecutive failures
+  WS_RETRY_INTERVAL_MS = 5 * 60 * 1000 // Retry WebSocket after 5 minutes
+
+// ============ HELPER FUNCTIONS ============
+
+/**
+ * Group exchanges by name and merge all pairs
+ * Returns: { exchange_instances: {}, exchange_all_pairs: {} }
+ */
+function group_exchanges_by_name(Exchanges, exchange_pair_dict) {
+  let exchange_instances = {}
+  let exchange_all_pairs = {}
+  for (let Exchange of Exchanges) {
+    let Exchange_name = _.upperFirst(Exchange.name)
+    if (!exchange_pair_dict[Exchange_name]) {
+      continue
+    }
+    if (!exchange_instances[Exchange_name]) {
+      exchange_instances[Exchange_name] = Exchange
+      exchange_all_pairs[Exchange_name] = []
+    }
+    exchange_all_pairs[Exchange_name] = _.union(exchange_all_pairs[Exchange_name], exchange_pair_dict[Exchange_name])
+  }
+  return { exchange_instances, exchange_all_pairs }
+}
+
+/**
+ * Set data in both exchange_pair and pair_exchange structures
+ */
+function set_pair_data(exchange_pair_dict, pair_exchange_dict, exchange_name, pair, data) {
+  _.set(exchange_pair_dict, [exchange_name, pair], data)
+  _.set(pair_exchange_dict, [pair, exchange_name], data)
+}
+
+/**
+ * Delete data from both exchange_pair and pair_exchange structures
+ */
+function delete_pair_data(exchange_pair_dict, pair_exchange_dict, exchange_name, pair) {
+  if (exchange_pair_dict[exchange_name]) {
+    delete exchange_pair_dict[exchange_name][pair]
+  }
+  if (pair_exchange_dict[pair]) {
+    delete pair_exchange_dict[pair][exchange_name]
+  }
+}
+
+/**
+ * Track WebSocket failure for a pair
+ */
+function track_ws_failure(failed_pairs_dict, exchange_name, pair) {
+  if (!failed_pairs_dict[exchange_name]) {
+    failed_pairs_dict[exchange_name] = {}
+  }
+  if (!failed_pairs_dict[exchange_name][pair]) {
+    failed_pairs_dict[exchange_name][pair] = { count: 0, last_failed: 0 }
+  }
+  failed_pairs_dict[exchange_name][pair].count++
+  failed_pairs_dict[exchange_name][pair].last_failed = Date.now()
+}
+
+/**
+ * Reset WebSocket failure count for a pair (on success)
+ */
+function reset_ws_failure(failed_pairs_dict, exchange_name, pair) {
+  if (failed_pairs_dict[exchange_name] && failed_pairs_dict[exchange_name][pair]) {
+    delete failed_pairs_dict[exchange_name][pair]
+  }
+}
+
+/**
+ * Check if pair should skip WebSocket due to persistent failures
+ */
+function should_skip_websocket(failed_pairs_dict, exchange_name, pair) {
+  const failure_info = failed_pairs_dict[exchange_name]?.[pair]
+  return (
+    failure_info &&
+    failure_info.count >= WS_FAILURE_THRESHOLD &&
+    (Date.now() - failure_info.last_failed) < WS_RETRY_INTERVAL_MS
+  )
+}
+
+/**
+ * Create WebSocket timeout checker
+ */
+function create_ws_timeout_checker(Exchange_name, timeout_ms, max_checks, on_timeout) {
+  const start_time = Date.now()
+  let check_count = 0
+  return () => {
+    check_count++
+    const elapsed = Date.now() - start_time
+    if (elapsed > timeout_ms || check_count > max_checks) {
+      on_timeout(elapsed)
+      return true
+    }
+    return false
+  }
+}
 
 const get_exchanges_rates = function (Exchanges, exchange_pair_dict, cb, ws_enabled = true) {
   let checked_rates = {}
@@ -14,38 +118,76 @@ const get_exchanges_rates = function (Exchanges, exchange_pair_dict, cb, ws_enab
     console.error('Exchanges should be an array')
     return
   } else {
-    for (let Exchange of Exchanges) {
-      let Exchange_name = _.upperFirst(Exchange.name)
-      if (checked_rates[Exchange_name]) {
-        continue
-      }
-      checked_rates[Exchange_name] = true
-      if (!exchange_pair_dict[Exchange_name]) {
-        continue
+    // First pass: group pairs by exchange name and find the Exchange instance
+    // This ensures ALL pairs for each exchange are collected BEFORE creating any WebSocket
+    const { exchange_instances, exchange_all_pairs } = group_exchanges_by_name(Exchanges, exchange_pair_dict)
+
+    // Second pass: process each unique exchange once
+    // Now we have all pairs collected, create ONE WebSocket per exchange with ALL pairs
+    for (let Exchange_name in exchange_instances) {
+      let Exchange = exchange_instances[Exchange_name]
+      let all_pairs = exchange_all_pairs[Exchange_name]
+      
+      // Log how many pairs will be used for this exchange
+      if (all_pairs.length > 0 && Exchange.ws_market && ws_enabled) {
+        console.log(`[WebSocket Rates] ${Exchange_name}: Creating connection with ${all_pairs.length} pair(s): ${all_pairs.join(', ')}`)
       }
+
       if (Exchange.ws_market && ws_enabled) {
-        let ws_promise = new Promise((resolve, reject) => {
-          if (!Exchange.ws || !Exchange.ws.market) {
-            console.error(`${Exchange_name} WebSocket not properly initialized`)
-            reject(new Error(`WebSocket not initialized for ${Exchange_name}`))
-            return
+        // Check if WebSocket is already opening/opened for this exchange
+        const ws_key = Exchange_name
+        const ws_status = Exchange.ws?.market?.status
+        const is_opening_or_opened = ws_status === 'opening' || ws_status === 'opened'
+
+        let ws_promise
+        let ws_promise_with_fallback
+        if (is_opening_or_opened && ws_connection_promises[ws_key]) {
+          // Reuse existing WebSocket connection promise
+          ws_promise = ws_connection_promises[ws_key]
+          // Merge pairs if needed
+          const existing_pairs = ws_connection_pairs[ws_key] || []
+          const new_pairs = _.difference(all_pairs, existing_pairs)
+          if (new_pairs.length > 0) {
+            ws_connection_pairs[ws_key] = _.union(existing_pairs, all_pairs)
+            // Add new pairs to existing connection if exchange supports it
+            // Note: This depends on exchange implementation - some may need to restart
+            // For now, we'll wait for existing connection and check if new pairs are already included
+          }
+          // Reuse wrapped promise with fallback if it exists (avoid duplicate catch handlers)
+          if (ws_connection_promises_with_fallback[ws_key]) {
+            ws_promise_with_fallback = ws_connection_promises_with_fallback[ws_key]
           }
+        } else {
+          // Create new WebSocket connection
+          ws_connection_pairs[ws_key] = all_pairs
+          ws_promise = new Promise((resolve, reject) => {
+            if (!Exchange.ws || !Exchange.ws.market) {
+              console.error(`${Exchange_name} WebSocket not properly initialized`)
+              reject(new Error(`WebSocket not initialized for ${Exchange_name}`))
+              return
+            }
 
-          Exchange.ws_market(exchange_pair_dict[Exchange_name])
+            // Store promise before starting connection
+            ws_connection_promises[ws_key] = ws_promise
+
+            // Create WebSocket with ALL pairs collected in first pass
+            // This ensures only ONE WebSocket per exchange, even with multiple clients/pairs
+            Exchange.ws_market(all_pairs)
 
           const WS_TIMEOUT_MS = 30000 // 30 seconds timeout
-          const start_time = Date.now()
-          let check_count = 0
           const MAX_CHECKS = 300 // 30 seconds / 100ms
-
-          const check_status = () => {
-            check_count++
-            const elapsed = Date.now() - start_time
-
-            // Timeout check
-            if (elapsed > WS_TIMEOUT_MS || check_count > MAX_CHECKS) {
+          const check_timeout = create_ws_timeout_checker(
+            Exchange_name,
+            WS_TIMEOUT_MS,
+            MAX_CHECKS,
+            (elapsed) => {
               console.error(`WebSocket timeout for ${Exchange_name} after ${elapsed}ms`)
               reject(new Error(`WebSocket timeout for ${Exchange_name}`))
+            }
+          )
+
+          const check_status = () => {
+            if (check_timeout()) {
               return
             }
 
@@ -56,74 +198,184 @@ const get_exchanges_rates = function (Exchanges, exchange_pair_dict, cb, ws_enab
               return
             }
 
-            let all_pairs_opened = exchange_pair_dict[Exchange_name].every((pair) => {
-              return (
-                Exchange.ws.market.pair_status &&
-                Exchange.ws.market.pair_status[pair] === 'opened' &&
-                Exchange.ws.market.asks_dict &&
-                Exchange.ws.market.asks_dict[pair] &&
-                Exchange.ws.market.asks_dict[pair].length > 0 &&
-                Exchange.ws.market.bids_dict &&
-                Exchange.ws.market.bids_dict[pair] &&
-                Exchange.ws.market.bids_dict[pair].length > 0
-              )
-            })
-            if (all_pairs_opened) {
-              let rate_promises = exchange_pair_dict[Exchange_name].map((pair) => {
+            // Check only the pairs we need for this call (not all pairs in connection)
+            let pairs_to_check = exchange_pair_dict[Exchange_name] || all_pairs
+            
+            // Check if WebSocket connection is at least opening/opened (not closed/stopped)
+            const ws_connection_ready = Exchange.ws.market.status === 'opening' || Exchange.ws.market.status === 'opened'
+            
+            if (ws_connection_ready) {
+              // Try each pair individually - wait a bit for pairs to become ready
+              // This allows us to detect individual pair failures while giving time for subscription
+              const PAIR_READY_TIMEOUT_MS = 10000 // Wait up to 10 seconds for pair to become ready
+              const PAIR_CHECK_INTERVAL_MS = 100 // Check every 100ms
+              
+              let rate_promises = pairs_to_check.map((pair) => {
                 return new Promise((rate_resolve) => {
-                  Exchange.rate_ws(pair, function (res) {
-                    if (res.success) {
-                      _.set(exchange_pair_rates, [Exchange_name, pair], res.body)
-                      _.set(pair_exchange_rates, [pair, Exchange_name], res.body)
+                  // Check if this pair should skip WebSocket due to persistent failures
+                  if (should_skip_websocket(ws_failed_pairs, Exchange_name, pair)) {
+                    const failure_info = ws_failed_pairs[Exchange_name][pair]
+                    console.log(`[WebSocket Skip] ${Exchange_name} ${pair}: Skipping WebSocket (${failure_info.count} consecutive failures, last failed ${Math.round((Date.now() - failure_info.last_failed) / 1000)}s ago)`)
+                    rate_resolve({ pair, failed: true, skip_ws: true })
+                    return
+                  }
+                  
+                  // Wait for pair to become ready with retry logic
+                  const pair_start_time = Date.now()
+                  const check_pair_ready = () => {
+                    // Check if this specific pair is ready before calling rate_ws
+                    const pair_ready = (
+                      Exchange.ws.market.pair_status &&
+                      Exchange.ws.market.pair_status[pair] === 'opened' &&
+                      Exchange.ws.market.asks_dict &&
+                      Exchange.ws.market.asks_dict[pair] &&
+                      Exchange.ws.market.asks_dict[pair].length > 0 &&
+                      Exchange.ws.market.bids_dict &&
+                      Exchange.ws.market.bids_dict[pair] &&
+                      Exchange.ws.market.bids_dict[pair].length > 0
+                    )
+                    
+                    if (pair_ready) {
+                      // Pair is ready, try to get rate
+                      Exchange.rate_ws(pair, function (res) {
+                        if (res.success) {
+                          // Success - reset failure count
+                          reset_ws_failure(ws_failed_pairs, Exchange_name, pair)
+                          set_pair_data(exchange_pair_rates, pair_exchange_rates, Exchange_name, pair, res.body)
+                          rate_resolve({ pair, failed: false })
+                        } else {
+                          console.error(`getting rate ws failed for ${Exchange_name} ${pair}:`, res)
+                          delete_pair_data(exchange_pair_rates, pair_exchange_rates, Exchange_name, pair)
+                          track_ws_failure(ws_failed_pairs, Exchange_name, pair)
+                          rate_resolve({ pair, failed: true })
+                        }
+                      })
                     } else {
-                      console.error(`getting rate ws failed for ${Exchange_name} ${pair}:`, res)
-                      if (exchange_pair_rates[Exchange_name]) {
-                        delete exchange_pair_rates[Exchange_name][pair]
-                      }
-                      if (pair_exchange_rates[pair]) {
-                        delete pair_exchange_rates[pair][Exchange_name]
+                      // Pair not ready yet - check if we've exceeded timeout
+                      const elapsed = Date.now() - pair_start_time
+                      if (elapsed >= PAIR_READY_TIMEOUT_MS) {
+                        // Timeout reached - mark as failed, will fall back to REST
+                        console.log(`[WebSocket] ${Exchange_name} ${pair}: Not ready after ${elapsed}ms (status: ${Exchange.ws.market.pair_status?.[pair] || 'unknown'})`)
+                        rate_resolve({ pair, failed: true })
+                      } else {
+                        // Retry after a short delay
+                        setTimeout(check_pair_ready, PAIR_CHECK_INTERVAL_MS)
                       }
                     }
-                    rate_resolve()
-                  })
+                  }
+                  
+                  // Start checking
+                  check_pair_ready()
                 })
               })
               Promise.all(rate_promises)
-                .then(() => {
-                  //   if (Exchange.ws.market.end_base) {
-                  //     Exchange.ws.market.end_base();  // Close the connection and prevent reconnection
-                  //     console.log(`${Exchange_name} WebSocket connection closed.`);
-                  // }
-                  resolve()
+                .then((results) => {
+                  // Check which pairs failed and fall back to REST for those pairs only
+                  const failed_pairs = results.filter((r) => r && r.failed).map((r) => r.pair)
+                  if (failed_pairs.length > 0 && Exchange.rate) {
+                    console.log(`[WebSocket Fallback] ${Exchange_name}: Falling back to REST for ${failed_pairs.length} pair(s): ${failed_pairs.join(', ')}`)
+                    const rest_promises = failed_pairs.map((pair) => {
+                      return new Promise((rest_resolve) => {
+                        Exchange.rate(pair, DEFAULT_ORDERBOOK_LEVEL, function (res) {
+                          if (res.success) {
+                            set_pair_data(exchange_pair_rates, pair_exchange_rates, Exchange_name, pair, res.body)
+                            console.log(`[REST Fallback] ${Exchange_name} ${pair}: Successfully fetched via REST`)
+                          } else {
+                            console.error(`[REST Fallback] getting rate failed for ${Exchange_name} ${pair}:`, res)
+                            delete_pair_data(exchange_pair_rates, pair_exchange_rates, Exchange_name, pair)
+                          }
+                          rest_resolve()
+                        })
+                      })
+                    })
+                    // Wait for REST fallback to complete before resolving
+                    return Promise.all(rest_promises)
+                      .catch((err) => {
+                        console.error(`[REST Fallback] Error fetching rates for ${Exchange_name}:`, err)
+                      })
+                      .then(() => {
+                        // Resolve after REST fallback completes
+                        resolve()
+                      })
+                  } else {
+                    //   if (Exchange.ws.market.end_base) {
+                    //     Exchange.ws.market.end_base();  // Close the connection and prevent reconnection
+                    //     console.log(`${Exchange_name} WebSocket connection closed.`);
+                    // }
+                    resolve()
+                  }
                 })
                 .catch((err) => {
                   console.error(`Error in rate_ws for ${Exchange_name}:`, err)
                   resolve()
                 })
             } else {
+              // WebSocket connection not ready yet, wait and retry
               setTimeout(check_status, 100)
             }
           }
 
           check_status()
         })
+        // Clean up promise reference when done (but keep connection open for reuse)
+        ws_promise.finally(() => {
+          // Don't delete immediately - keep for a short time to allow reuse
+          setTimeout(() => {
+            if (ws_connection_promises[ws_key] === ws_promise) {
+              delete ws_connection_promises[ws_key]
+              // Also clean up wrapped promise if it exists
+              if (ws_connection_promises_with_fallback[ws_key]) {
+                delete ws_connection_promises_with_fallback[ws_key]
+              }
+            }
+          }, 1000)
+        })
+        }
 
-        promises.push(ws_promise)
+        // Wrap WebSocket promise to handle rejection and fall back to REST
+        // Only create wrapper if it doesn't exist (avoid duplicate catch handlers on reused promises)
+        if (!ws_promise_with_fallback) {
+          ws_promise_with_fallback = ws_promise.catch((err) => {
+            console.error(`[WebSocket Failed] ${Exchange_name}: Falling back to REST for all pairs. Error:`, err.message)
+            // Fall back to REST for all pairs
+            if (Exchange.rate) {
+              return Promise.all(
+                all_pairs.map((pair) => {
+                  return new Promise((rest_resolve) => {
+                    Exchange.rate(pair, DEFAULT_ORDERBOOK_LEVEL, function (res) {
+                      if (res.success) {
+                        set_pair_data(exchange_pair_rates, pair_exchange_rates, Exchange_name, pair, res.body)
+                        console.log(`[REST Fallback] ${Exchange_name} ${pair}: Successfully fetched via REST`)
+                      } else {
+                        console.error(`[REST Fallback] getting rate failed for ${Exchange_name} ${pair}:`, res)
+                        delete_pair_data(exchange_pair_rates, pair_exchange_rates, Exchange_name, pair)
+                      }
+                      rest_resolve()
+                    })
+                  })
+                })
+              ).then(() => {
+                // Resolve after REST fallback completes
+                return Promise.resolve()
+              })
+            }
+            // If no REST fallback available, still resolve to prevent Promise.all from failing
+            return Promise.resolve()
+          })
+          // Store wrapped promise for reuse
+          ws_connection_promises_with_fallback[ws_key] = ws_promise_with_fallback
+        }
+        promises.push(ws_promise_with_fallback)
       } else if (Exchange.rate) {
-        let rate_promises = exchange_pair_dict[Exchange_name].map((pair) => {
+        let pairs_to_fetch = exchange_pair_dict[Exchange_name] || all_pairs
+        let rate_promises = pairs_to_fetch.map((pair) => {
           return new Promise((resolve, reject) => {
             Exchange.rate(pair, DEFAULT_ORDERBOOK_LEVEL, function (res) {
               if (res.success) {
-                _.set(exchange_pair_rates, [Exchange_name, pair], res.body)
-                _.set(pair_exchange_rates, [pair, Exchange_name], res.body)
+                set_pair_data(exchange_pair_rates, pair_exchange_rates, Exchange_name, pair, res.body)
               } else {
                 console.error(`getting rate failed for ${Exchange_name} ${pair}:`, res)
-                if (exchange_pair_rates[Exchange_name]) {
-                  delete exchange_pair_rates[Exchange_name][pair]
-                }
-                if (pair_exchange_rates[pair]) {
-                  delete pair_exchange_rates[pair][Exchange_name]
-                }
+                delete_pair_data(exchange_pair_rates, pair_exchange_rates, Exchange_name, pair)
               }
               resolve()
             })
@@ -132,23 +384,18 @@ const get_exchanges_rates = function (Exchanges, exchange_pair_dict, cb, ws_enab
 
         promises = promises.concat(rate_promises) // Add all rate promises
       } else if (Exchange.rate_with_routes) {
-        let rate_with_routes_promises = exchange_pair_dict[Exchange_name].map((pair) => {
+        let pairs_to_fetch = exchange_pair_dict[Exchange_name] || all_pairs
+        let rate_with_routes_promises = pairs_to_fetch.map((pair) => {
           return new Promise((resolve, reject) => {
             Exchange.rate_with_routes(pair, function (res) {
               if (res.success) {
                 let { asks, bids } = res.body
                 asks = asks.map((ask) => ask.slice(0, 2))
                 bids = bids.map((bid) => bid.slice(0, 2))
-                _.set(exchange_pair_rates, [Exchange_name, pair], { asks, bids })
-                _.set(pair_exchange_rates, [pair, Exchange_name], { asks, bids })
+                set_pair_data(exchange_pair_rates, pair_exchange_rates, Exchange_name, pair, { asks, bids })
               } else {
                 console.error(`getting rate with routes failed for ${Exchange_name} ${pair}:`, res)
-                if (exchange_pair_rates[Exchange_name]) {
-                  delete exchange_pair_rates[Exchange_name][pair]
-                }
-                if (pair_exchange_rates[pair]) {
-                  delete pair_exchange_rates[pair][Exchange_name]
-                }
+                delete_pair_data(exchange_pair_rates, pair_exchange_rates, Exchange_name, pair)
               }
               resolve()
             })
@@ -172,7 +419,14 @@ const get_exchanges_rates = function (Exchanges, exchange_pair_dict, cb, ws_enab
 }
 
 let exchange_pair_market_history = {},
-  pair_exchange_market_history = {}
+  pair_exchange_market_history = {},
+  // Track active WebSocket connections for market history
+  ws_market_history_promises = {},
+  ws_market_history_pairs = {},
+  // Track wrapped promises with fallback handlers to avoid duplicate handlers
+  ws_market_history_promises_with_fallback = {},
+  // Track persistent WebSocket failures for market history
+  ws_market_history_failed_pairs = {} // { "ExchangeName": { "PAIR": { count: number, last_failed: timestamp } } }
 const get_exchanges_market_history = function (Exchanges, exchange_pair_dict, timeframe_in_ms, cb, ws_enabled = true) {
   let checked_market_history = {}
   let promises = []
@@ -181,41 +435,71 @@ const get_exchanges_market_history = function (Exchanges, exchange_pair_dict, ti
     console.error('Exchanges should be an array')
     return
   } else {
-    for (let Exchange of Exchanges) {
-      let Exchange_name = _.upperFirst(Exchange.name)
-      if (checked_market_history[Exchange_name]) {
-        continue
-      }
-      checked_market_history[Exchange_name] = true
-      if (!exchange_pair_dict[Exchange_name]) {
-        continue
-      }
+    // First pass: group pairs by exchange name and find the Exchange instance
+    const { exchange_instances, exchange_all_pairs } = group_exchanges_by_name(Exchanges, exchange_pair_dict)
+
+    // Second pass: process each unique exchange once
+    for (let Exchange_name in exchange_instances) {
+      let Exchange = exchange_instances[Exchange_name]
+      let all_pairs = exchange_all_pairs[Exchange_name]
+
       if (Exchange.ws_market && ws_enabled) {
-        let ws_promise = new Promise((resolve, reject) => {
-          if (!Exchange.ws || !Exchange.ws.market) {
-            console.error(`${Exchange_name} WebSocket not properly initialized`)
-            reject(new Error(`WebSocket not initialized for ${Exchange_name}`))
-            return
-          }
+        // Check if WebSocket is already opening/opened for this exchange
+        const ws_key = `market_history_${Exchange_name}`
+        const ws_status = Exchange.ws?.market?.status
+        const is_opening_or_opened = ws_status === 'opening' || ws_status === 'opened'
 
-          if (!first_time[Exchange_name]) {
-            Exchange.ws_market(exchange_pair_dict[Exchange_name])
-            first_time[Exchange_name] = true
+        let ws_promise
+        let ws_promise_with_fallback
+        if (is_opening_or_opened && ws_market_history_promises[ws_key]) {
+          // Reuse existing WebSocket connection promise
+          ws_promise = ws_market_history_promises[ws_key]
+          // Merge pairs if needed
+          const existing_pairs = ws_market_history_pairs[ws_key] || []
+          const new_pairs = _.difference(all_pairs, existing_pairs)
+          if (new_pairs.length > 0) {
+            ws_market_history_pairs[ws_key] = _.union(existing_pairs, all_pairs)
+          }
+          // Reuse wrapped promise with fallback if it exists (avoid duplicate catch handlers)
+          if (ws_market_history_promises_with_fallback[ws_key]) {
+            ws_promise_with_fallback = ws_market_history_promises_with_fallback[ws_key]
           }
+        } else {
+          // Create new WebSocket connection (or use existing one from rates)
+          ws_market_history_pairs[ws_key] = all_pairs
+          ws_promise = new Promise((resolve, reject) => {
+            if (!Exchange.ws || !Exchange.ws.market) {
+              console.error(`${Exchange_name} WebSocket not properly initialized`)
+              reject(new Error(`WebSocket not initialized for ${Exchange_name}`))
+              return
+            }
 
-          const WS_TIMEOUT_MS = 30000 // 30 seconds timeout
-          const start_time = Date.now()
-          let check_count = 0
-          const MAX_CHECKS = 300 // 30 seconds / 100ms
+            // Store promise before starting connection
+            ws_market_history_promises[ws_key] = ws_promise
 
-          const check_status = () => {
-            check_count++
-            const elapsed = Date.now() - start_time
+            // Only start if not already started (reuse connection from rates if available)
+            // If starting new, use ALL pairs collected in first pass
+            if (!first_time[Exchange_name]) {
+              // Create WebSocket with ALL pairs collected in first pass
+              // This ensures only ONE WebSocket per exchange, even with multiple clients/pairs
+              Exchange.ws_market(all_pairs)
+              first_time[Exchange_name] = true
+            }
 
-            // Timeout check
-            if (elapsed > WS_TIMEOUT_MS || check_count > MAX_CHECKS) {
+          const WS_TIMEOUT_MS = 30000 // 30 seconds timeout
+          const MAX_CHECKS = 300 // 30 seconds / 100ms
+          const check_timeout = create_ws_timeout_checker(
+            Exchange_name,
+            WS_TIMEOUT_MS,
+            MAX_CHECKS,
+            (elapsed) => {
               console.error(`WebSocket timeout for ${Exchange_name} market history after ${elapsed}ms`)
               reject(new Error(`WebSocket timeout for ${Exchange_name} market history`))
+            }
+          )
+
+          const check_status = () => {
+            if (check_timeout()) {
               return
             }
 
@@ -226,37 +510,106 @@ const get_exchanges_market_history = function (Exchanges, exchange_pair_dict, ti
               return
             }
 
-            let all_pairs_opened = exchange_pair_dict[Exchange_name].every((pair) => {
-              return (
-                Exchange.ws.market.pair_status &&
-                Exchange.ws.market.pair_status[pair] === 'opened' &&
-                Exchange.ws.market.market_history_dict &&
-                Exchange.ws.market.market_history_dict[pair] &&
-                Exchange.ws.market.market_history_dict[pair].length >= 0
-              )
-            })
-            if (all_pairs_opened) {
-              let market_history_promises = exchange_pair_dict[Exchange_name].map((pair) => {
+            // Check only the pairs we need for this call
+            let pairs_to_check = exchange_pair_dict[Exchange_name] || all_pairs
+            
+            // Check if WebSocket connection is at least opening/opened (not closed/stopped)
+            const ws_connection_ready = Exchange.ws.market.status === 'opening' || Exchange.ws.market.status === 'opened'
+            
+            if (ws_connection_ready) {
+              // Try each pair individually - wait a bit for pairs to become ready
+              // This allows us to detect individual pair failures while giving time for subscription
+              const PAIR_READY_TIMEOUT_MS = 10000 // Wait up to 10 seconds for pair to become ready
+              const PAIR_CHECK_INTERVAL_MS = 100 // Check every 100ms
+              
+              let market_history_promises = pairs_to_check.map((pair) => {
                 return new Promise((rate_resolve) => {
-                  Exchange.market_history_ws(pair, timeframe_in_ms, function (res) {
-                    if (res.success) {
-                      _.set(exchange_pair_market_history, [Exchange_name, pair], res.body)
-                      _.set(pair_exchange_market_history, [pair, Exchange_name], res.body)
+                  // Check if this pair should skip WebSocket due to persistent failures
+                  if (should_skip_websocket(ws_market_history_failed_pairs, Exchange_name, pair)) {
+                    const failure_info = ws_market_history_failed_pairs[Exchange_name][pair]
+                    console.log(`[WebSocket Skip] ${Exchange_name} ${pair} market history: Skipping WebSocket (${failure_info.count} consecutive failures, last failed ${Math.round((Date.now() - failure_info.last_failed) / 1000)}s ago)`)
+                    rate_resolve({ pair, failed: true, skip_ws: true })
+                    return
+                  }
+                  
+                  // Wait for pair to become ready with retry logic
+                  const pair_start_time = Date.now()
+                  const check_pair_ready = () => {
+                    // Check if this specific pair is ready before calling market_history_ws
+                    const pair_ready = (
+                      Exchange.ws.market.pair_status &&
+                      Exchange.ws.market.pair_status[pair] === 'opened' &&
+                      Exchange.ws.market.market_history_dict &&
+                      Exchange.ws.market.market_history_dict[pair] &&
+                      Exchange.ws.market.market_history_dict[pair].length >= 0
+                    )
+                    
+                    if (pair_ready) {
+                      // Pair is ready, try to get market history
+                      Exchange.market_history_ws(pair, timeframe_in_ms, function (res) {
+                        if (res.success) {
+                          // Success - reset failure count
+                          reset_ws_failure(ws_market_history_failed_pairs, Exchange_name, pair)
+                          set_pair_data(exchange_pair_market_history, pair_exchange_market_history, Exchange_name, pair, res.body)
+                          rate_resolve({ pair, failed: false })
+                        } else {
+                          console.error(`getting market history ws failed for ${Exchange_name} ${pair}:`, res)
+                          delete_pair_data(exchange_pair_market_history, pair_exchange_market_history, Exchange_name, pair)
+                          track_ws_failure(ws_market_history_failed_pairs, Exchange_name, pair)
+                          rate_resolve({ pair, failed: true })
+                        }
+                      })
                     } else {
-                      console.error(`getting market history ws failed for ${Exchange_name} ${pair}:`, res)
-                      if (exchange_pair_market_history[Exchange_name]) {
-                        delete exchange_pair_market_history[Exchange_name][pair]
-                      }
-                      if (pair_exchange_market_history[pair]) {
-                        delete pair_exchange_market_history[pair][Exchange_name]
+                      // Pair not ready yet - check if we've exceeded timeout
+                      const elapsed = Date.now() - pair_start_time
+                      if (elapsed >= PAIR_READY_TIMEOUT_MS) {
+                        // Timeout reached - mark as failed, will fall back to REST
+                        console.log(`[WebSocket Market History] ${Exchange_name} ${pair}: Not ready after ${elapsed}ms (status: ${Exchange.ws.market.pair_status?.[pair] || 'unknown'})`)
+                        rate_resolve({ pair, failed: true })
+                      } else {
+                        // Retry after a short delay
+                        setTimeout(check_pair_ready, PAIR_CHECK_INTERVAL_MS)
                       }
                     }
-                    rate_resolve()
-                  })
+                  }
+                  
+                  // Start checking
+                  check_pair_ready()
                 })
               })
               Promise.all(market_history_promises)
-                .then(() => resolve())
+                .then((results) => {
+                  // Check which pairs failed and fall back to REST for those pairs only
+                  const failed_pairs = results.filter((r) => r && r.failed).map((r) => r.pair)
+                  if (failed_pairs.length > 0 && Exchange.market_history) {
+                    console.log(`[WebSocket Fallback] ${Exchange_name} market history: Falling back to REST for ${failed_pairs.length} pair(s): ${failed_pairs.join(', ')}`)
+                    const rest_promises = failed_pairs.map((pair) => {
+                      return new Promise((rest_resolve) => {
+                        Exchange.market_history(pair, timeframe_in_ms, function (res) {
+                          if (res.success) {
+                            set_pair_data(exchange_pair_market_history, pair_exchange_market_history, Exchange_name, pair, res.body)
+                            console.log(`[REST Fallback] ${Exchange_name} ${pair} market history: Successfully fetched via REST`)
+                          } else {
+                            console.error(`[REST Fallback] getting market history failed for ${Exchange_name} ${pair}:`, res)
+                            delete_pair_data(exchange_pair_market_history, pair_exchange_market_history, Exchange_name, pair)
+                          }
+                          rest_resolve()
+                        })
+                      })
+                    })
+                    // Wait for REST fallback to complete before resolving
+                    return Promise.all(rest_promises)
+                      .catch((err) => {
+                        console.error(`[REST Fallback] Error fetching market history for ${Exchange_name}:`, err)
+                      })
+                      .then(() => {
+                        // Resolve after REST fallback completes
+                        resolve()
+                      })
+                  } else {
+                    resolve()
+                  }
+                })
                 .catch((err) => {
                   console.error(`Error in market_history_ws for ${Exchange_name}:`, err)
                   resolve()
@@ -267,22 +620,64 @@ const get_exchanges_market_history = function (Exchanges, exchange_pair_dict, ti
           }
           check_status()
         })
-        promises.push(ws_promise)
+        // Clean up promise reference when done (but keep connection open for reuse)
+        ws_promise.finally(() => {
+          setTimeout(() => {
+            if (ws_market_history_promises[ws_key] === ws_promise) {
+              delete ws_market_history_promises[ws_key]
+              // Also clean up wrapped promise if it exists
+              if (ws_market_history_promises_with_fallback[ws_key]) {
+                delete ws_market_history_promises_with_fallback[ws_key]
+              }
+            }
+          }, 1000)
+        })
+        }
+
+        // If WebSocket promise rejects (timeout/error), fall back to REST for all pairs
+        // Only create wrapper if it doesn't exist (avoid duplicate catch handlers on reused promises)
+        if (!ws_promise_with_fallback) {
+          ws_promise_with_fallback = ws_promise.catch((err) => {
+            console.error(`[WebSocket Failed] ${Exchange_name} market history: Falling back to REST for all pairs. Error:`, err.message)
+            // Fall back to REST for all pairs
+            if (Exchange.market_history) {
+              return Promise.all(
+                all_pairs.map((pair) => {
+                  return new Promise((rest_resolve) => {
+                    Exchange.market_history(pair, timeframe_in_ms, function (res) {
+                      if (res.success) {
+                        set_pair_data(exchange_pair_market_history, pair_exchange_market_history, Exchange_name, pair, res.body)
+                        console.log(`[REST Fallback] ${Exchange_name} ${pair} market history: Successfully fetched via REST`)
+                      } else {
+                        console.error(`[REST Fallback] getting market history failed for ${Exchange_name} ${pair}:`, res)
+                        delete_pair_data(exchange_pair_market_history, pair_exchange_market_history, Exchange_name, pair)
+                      }
+                      rest_resolve()
+                    })
+                  })
+                })
+              ).then(() => {
+                // Resolve after REST fallback completes
+                return Promise.resolve()
+              })
+            }
+            // If no REST fallback available, still resolve to prevent Promise.all from failing
+            return Promise.resolve()
+          })
+          // Store wrapped promise for reuse
+          ws_market_history_promises_with_fallback[ws_key] = ws_promise_with_fallback
+        }
+        promises.push(ws_promise_with_fallback)
       } else if (Exchange.market_history) {
-        let market_history_promises = exchange_pair_dict[Exchange_name].map((pair) => {
+        let pairs_to_fetch = exchange_pair_dict[Exchange_name] || all_pairs
+        let market_history_promises = pairs_to_fetch.map((pair) => {
           return new Promise((resolve) => {
             Exchange.market_history(pair, timeframe_in_ms, function (res) {
               if (res.success) {
-                _.set(exchange_pair_market_history, [Exchange_name, pair], res.body)
-                _.set(pair_exchange_market_history, [pair, Exchange_name], res.body)
+                set_pair_data(exchange_pair_market_history, pair_exchange_market_history, Exchange_name, pair, res.body)
               } else {
                 console.error(`getting market history failed for ${Exchange_name} ${pair}:`, res)
-                if (exchange_pair_market_history[Exchange_name]) {
-                  delete exchange_pair_market_history[Exchange_name][pair]
-                }
-                if (pair_exchange_market_history[pair]) {
-                  delete pair_exchange_market_history[pair][Exchange_name]
-                }
+                delete_pair_data(exchange_pair_market_history, pair_exchange_market_history, Exchange_name, pair)
               }
               resolve()
             })
@@ -330,16 +725,10 @@ const get_exchanges_ohlcv = function (Exchanges, exchange_pair_dict, from_in_ms,
         if (Exchange.ohlcv) {
           Exchange.ohlcv(pair, from_in_ms, to_in_ms, function (res) {
             if (res.success) {
-              _.set(exchange_pair_ohlcv, [Exchange_name, pair], res.body)
-              _.set(pair_exchange_ohlcv, [pair, Exchange_name], res.body)
+              set_pair_data(exchange_pair_ohlcv, pair_exchange_ohlcv, Exchange_name, pair, res.body)
             } else {
               console.error(`getting ohlcv failed for ${Exchange_name} ${pair}:`, res)
-              if (exchange_pair_ohlcv[Exchange_name]) {
-                delete exchange_pair_ohlcv[Exchange_name][pair]
-              }
-              if (pair_exchange_ohlcv[pair]) {
-                delete pair_exchange_ohlcv[pair][Exchange_name]
-              }
+              delete_pair_data(exchange_pair_ohlcv, pair_exchange_ohlcv, Exchange_name, pair)
             }
             _.set(ohlcv_status, [Exchange_name + pair], true)
             // Use a flag to prevent multiple callback calls

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icgio/icg-exchanges-wrapper",
-  "version": "1.14.256",
+  "version": "1.14.258",
   "description": "",
   "main": "index.js",
   "scripts": {