@icgio/icg-exchanges-wrapper 1.15.1 → 1.15.3

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

@@ -86,11 +86,7 @@ function reset_ws_failure(failed_pairs_dict, exchange_name, pair) {
  */
 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
-  )
+  return failure_info && failure_info.count >= WS_FAILURE_THRESHOLD && Date.now() - failure_info.last_failed < WS_RETRY_INTERVAL_MS
 }
 
 /**
@@ -127,7 +123,7 @@ const get_exchanges_rates = function (Exchanges, exchange_pair_dict, cb, ws_enab
     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) {
         // Check if WebSocket is already opening/opened for this exchange
         const ws_key = Exchange_name
@@ -173,162 +169,158 @@ const get_exchanges_rates = function (Exchanges, exchange_pair_dict, cb, ws_enab
             // 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 MAX_CHECKS = 300 // 30 seconds / 100ms
-          const check_timeout = create_ws_timeout_checker(
-            Exchange_name,
-            WS_TIMEOUT_MS,
-            MAX_CHECKS,
-            (elapsed) => {
+            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} after ${elapsed}ms`)
               reject(new Error(`WebSocket timeout for ${Exchange_name}`))
-            }
-          )
+            })
 
-          const check_status = () => {
-            if (check_timeout()) {
-              return
-            }
+            const check_status = () => {
+              if (check_timeout()) {
+                return
+              }
 
-            // Safety check for WebSocket object
-            if (!Exchange.ws || !Exchange.ws.market) {
-              console.error(`${Exchange_name} WebSocket object missing during check`)
-              reject(new Error(`WebSocket object missing for ${Exchange_name}`))
-              return
-            }
+              // Safety check for WebSocket object
+              if (!Exchange.ws || !Exchange.ws.market) {
+                console.error(`${Exchange_name} WebSocket object missing during check`)
+                reject(new Error(`WebSocket object missing for ${Exchange_name}`))
+                return
+              }
 
-            // 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) => {
-                  // 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 {
-                      // 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)
-                      }
+              // 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) => {
+                    // 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
                     }
-                  }
-                  
-                  // Start checking
-                  check_pair_ready()
-                })
-              })
-              Promise.all(rate_promises)
-                .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) {
+
+                    // 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)
-                            console.log(`[REST Fallback] ${Exchange_name} ${pair}: Successfully fetched via REST`)
+                            rate_resolve({ pair, failed: false })
                           } else {
-                            console.error(`[REST Fallback] getting rate failed for ${Exchange_name} ${pair}:`, res)
+                            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 })
                           }
-                          rest_resolve()
+                        })
+                      } else {
+                        // 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)
+                        }
+                      }
+                    }
+
+                    // Start checking
+                    check_pair_ready()
+                  })
+                })
+                Promise.all(rate_promises)
+                  .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.`);
-                    // }
+                      // 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()
-                  }
-                })
-                .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)
+                  })
+              } 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]
+            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)
-        })
+            }, 1000)
+          })
         }
 
         // Wrap WebSocket promise to handle rejection and fall back to REST
@@ -352,7 +344,7 @@ const get_exchanges_rates = function (Exchanges, exchange_pair_dict, cb, ws_enab
                       rest_resolve()
                     })
                   })
-                })
+                }),
               ).then(() => {
                 // Resolve after REST fallback completes
                 return Promise.resolve()
@@ -485,152 +477,150 @@ const get_exchanges_market_history = function (Exchanges, exchange_pair_dict, ti
               first_time[Exchange_name] = true
             }
 
-          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) => {
+            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
-            }
+            const check_status = () => {
+              if (check_timeout()) {
+                return
+              }
 
-            // Safety check for WebSocket object
-            if (!Exchange.ws || !Exchange.ws.market) {
-              console.error(`${Exchange_name} WebSocket object missing during check`)
-              reject(new Error(`WebSocket object missing for ${Exchange_name}`))
-              return
-            }
+              // Safety check for WebSocket object
+              if (!Exchange.ws || !Exchange.ws.market) {
+                console.error(`${Exchange_name} WebSocket object missing during check`)
+                reject(new Error(`WebSocket object missing for ${Exchange_name}`))
+                return
+              }
 
-            // 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) => {
-                  // 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 {
-                      // 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)
-                      }
+              // 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) => {
+                    // 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
                     }
-                  }
-                  
-                  // Start checking
-                  check_pair_ready()
-                })
-              })
-              Promise.all(market_history_promises)
-                .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) {
+
+                    // 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)
-                            console.log(`[REST Fallback] ${Exchange_name} ${pair} market history: Successfully fetched via REST`)
+                            rate_resolve({ pair, failed: false })
                           } else {
-                            console.error(`[REST Fallback] getting market history failed for ${Exchange_name} ${pair}:`, res)
+                            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 })
                           }
-                          rest_resolve()
+                        })
+                      } else {
+                        // 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)
+                        }
+                      }
+                    }
+
+                    // Start checking
+                    check_pair_ready()
+                  })
+                })
+                Promise.all(market_history_promises)
+                  .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 {
+                      // 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()
-                  }
-                })
-                .catch((err) => {
-                  console.error(`Error in market_history_ws for ${Exchange_name}:`, err)
-                  resolve()
-                })
-            } else {
-              setTimeout(check_status, 100)
-            }
-          }
-          check_status()
-        })
-        // 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]
+                  })
+              } else {
+                setTimeout(check_status, 100)
               }
             }
-          }, 1000)
-        })
+            check_status()
+          })
+          // 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
@@ -654,7 +644,7 @@ const get_exchanges_market_history = function (Exchanges, exchange_pair_dict, ti
                       rest_resolve()
                     })
                   })
-                })
+                }),
               ).then(() => {
                 // Resolve after REST fallback completes
                 return Promise.resolve()
@@ -700,12 +690,13 @@ const get_exchanges_market_history = function (Exchanges, exchange_pair_dict, ti
 
 let checked_ohlcv_exchange = {},
   ohlcv_status = {},
+  ohlcv_callback_fired = false, // Separate flag to prevent multiple callback calls
   exchange_pair_ohlcv = {},
   pair_exchange_ohlcv = {}
 const get_exchanges_ohlcv = function (Exchanges, exchange_pair_dict, from_in_ms, to_in_ms, cb) {
   checked_ohlcv_exchange = {}
   ohlcv_status = {}
-  ohlcv_status._callback_fired = false // Reset callback flag
+  ohlcv_callback_fired = false // Reset callback flag (separate from ohlcv_status to not pollute _.values())
   if (!Array.isArray(Exchanges)) {
     console.error('Exchanges should be an array')
     return
@@ -731,16 +722,16 @@ const get_exchanges_ohlcv = function (Exchanges, exchange_pair_dict, from_in_ms,
             }
             _.set(ohlcv_status, [Exchange_name + pair], true)
             // Use a flag to prevent multiple callback calls
-            if (!_.includes(_.values(ohlcv_status), false) && !ohlcv_status._callback_fired) {
-              ohlcv_status._callback_fired = true
+            if (!_.includes(_.values(ohlcv_status), false) && !ohlcv_callback_fired) {
+              ohlcv_callback_fired = true
               cb({ exchange_pair_ohlcv, pair_exchange_ohlcv })
             }
           })
         } else {
           _.set(ohlcv_status, [Exchange_name + pair], true)
           // Use a flag to prevent multiple callback calls
-          if (!_.includes(_.values(ohlcv_status), false) && !ohlcv_status._callback_fired) {
-            ohlcv_status._callback_fired = true
+          if (!_.includes(_.values(ohlcv_status), false) && !ohlcv_callback_fired) {
+            ohlcv_callback_fired = true
             cb({ exchange_pair_ohlcv, pair_exchange_ohlcv })
           }
         }

package/package.json

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