refactor: centralize CCXT instance caching with ccxtInstanceManager

experiments/test-refactoring.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+/**
+ * Simple test script to validate ccxtInstanceManager refactoring
+ * This script verifies that:
+ * 1. ccxtInstanceManager is properly exported
+ * 2. No direct CCXT instantiations remain except in fallback cases
+ * 3. ccxtBrowserProvider delegates to ccxtInstanceManager
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+console.log('🧪 Testing CCXT Instance Manager Refactoring');
+console.log('============================================');
+
+// Test 1: Verify ccxtInstanceManager export
+console.log('\n1. Checking ccxtInstanceManager export...');
+const ccxtInstanceManagerPath = '../src/store/utils/ccxtInstanceManager.ts';
+const ccxtInstanceManagerContent = fs.readFileSync(path.join(__dirname, ccxtInstanceManagerPath), 'utf8');
+
+if (ccxtInstanceManagerContent.includes('export const ccxtInstanceManager = new CCXTInstanceManager()')) {
+    console.log('✅ ccxtInstanceManager properly exported as singleton');
+} else {
+    console.log('❌ ccxtInstanceManager export not found');
+}
+
+// Test 2: Verify TestChartWidget.tsx uses ccxtInstanceManager
+console.log('\n2. Checking TestChartWidget.tsx...');
+const testChartWidgetPath = '../src/components/TestChartWidget.tsx';
+const testChartWidgetContent = fs.readFileSync(path.join(__dirname, testChartWidgetPath), 'utf8');
+
+if (testChartWidgetContent.includes('import { ccxtInstanceManager }')) {
+    console.log('✅ TestChartWidget imports ccxtInstanceManager');
+} else {
+    console.log('❌ TestChartWidget does not import ccxtInstanceManager');
+}
+
+if (testChartWidgetContent.includes('ccxtInstanceManager.getExchangeInstanceForMarket')) {
+    console.log('✅ TestChartWidget uses ccxtInstanceManager.getExchangeInstanceForMarket');
+} else {
+    console.log('❌ TestChartWidget does not use ccxtInstanceManager');
+}
+
+// Test 3: Verify TestTimeframes.tsx uses ccxtInstanceManager
+console.log('\n3. Checking TestTimeframes.tsx...');
+const testTimeframesPath = '../src/components/TestTimeframes.tsx';
+const testTimeframesContent = fs.readFileSync(path.join(__dirname, testTimeframesPath), 'utf8');
+
+if (testTimeframesContent.includes('import { ccxtInstanceManager }')) {
+    console.log('✅ TestTimeframes imports ccxtInstanceManager');
+} else {
+    console.log('❌ TestTimeframes does not import ccxtInstanceManager');
+}
+
+if (testTimeframesContent.includes('ccxtInstanceManager.getExchangeInstanceForMarket')) {
+    console.log('✅ TestTimeframes uses ccxtInstanceManager.getExchangeInstanceForMarket');
+} else {
+    console.log('❌ TestTimeframes does not use ccxtInstanceManager');
+}
+
+// Test 4: Verify ccxtBrowserProvider delegates to ccxtInstanceManager
+console.log('\n4. Checking ccxtBrowserProvider.ts...');
+const ccxtBrowserProviderPath = '../src/store/providers/ccxtBrowserProvider.ts';
+const ccxtBrowserProviderContent = fs.readFileSync(path.join(__dirname, ccxtBrowserProviderPath), 'utf8');
+
+if (ccxtBrowserProviderContent.includes('import { ccxtInstanceManager }')) {
+    console.log('✅ ccxtBrowserProvider imports ccxtInstanceManager');
+} else {
+    console.log('❌ ccxtBrowserProvider does not import ccxtInstanceManager');
+}
+
+if (ccxtBrowserProviderContent.includes('ccxtInstanceManager.getExchangeInstanceForMarket')) {
+    console.log('✅ ccxtBrowserProvider delegates to ccxtInstanceManager.getExchangeInstanceForMarket');
+} else {
+    console.log('❌ ccxtBrowserProvider does not delegate to ccxtInstanceManager');
+}
+
+if (ccxtBrowserProviderContent.includes('ccxtInstanceManager.clearCache')) {
+    console.log('✅ ccxtBrowserProvider delegates cache clearing to ccxtInstanceManager');
+} else {
+    console.log('❌ ccxtBrowserProvider does not delegate cache clearing');
+}
+
+// Test 5: Check for duplicate caching code removal
+console.log('\n5. Checking for duplicate cache removal...');
+
+if (!ccxtBrowserProviderContent.includes('private static instancesCache = new Map')) {
+    console.log('✅ Duplicate static instancesCache removed from ccxtBrowserProvider');
+} else {
+    console.log('❌ Duplicate static instancesCache still exists in ccxtBrowserProvider');
+}
+
+if (!ccxtBrowserProviderContent.includes('setInterval(() => {') ||
+    ccxtBrowserProviderContent.includes('Cleanup теперь управляется централизованно')) {
+    console.log('✅ Duplicate cleanup interval removed or replaced');
+} else {
+    console.log('❌ Duplicate cleanup interval still exists');
+}
+
+// Test 6: Check for remaining direct instantiations
+console.log('\n6. Checking for direct CCXT instantiations...');
+
+const filesToCheck = [
+    testChartWidgetPath,
+    testTimeframesPath,
+    ccxtBrowserProviderPath
+];
+
+let foundDirectInstantiations = 0;
+let expectedFallbackInstantiations = 0;
+
+filesToCheck.forEach(filePath => {
+    const content = fs.readFileSync(path.join(__dirname, filePath), 'utf8');
+    const directInstantiations = (content.match(/new ccxt\./g) || []).length;
+    const fallbackInstantiations = (content.match(/Fallback|fallback|CCXT Pro.*fallback/gi) || []).length;
+
+    foundDirectInstantiations += directInstantiations;
+    expectedFallbackInstantiations += fallbackInstantiations;
+
+    if (directInstantiations > 0) {
+        console.log(`   - ${path.basename(filePath)}: ${directInstantiations} direct instantiation(s) found`);
+    }
+});
+
+if (foundDirectInstantiations <= expectedFallbackInstantiations) {
+    console.log('✅ Direct CCXT instantiations limited to fallback cases only');
+} else {
+    console.log(`❌ Found ${foundDirectInstantiations} direct instantiations, expected only ${expectedFallbackInstantiations} fallback cases`);
+}
+
+console.log('\n🎯 Refactoring Summary:');
+console.log('- ccxtInstanceManager is now used as the central caching mechanism');
+console.log('- Test components use ccxtInstanceManager instead of direct instantiation');
+console.log('- ccxtBrowserProvider delegates to ccxtInstanceManager');
+console.log('- Duplicate caching code has been removed');
+console.log('- CCXT Pro has fallback logic until ccxtInstanceManager supports it');
+
+console.log('\n✅ Refactoring validation completed!');

src/components/TestChartWidget.tsx

@@ -1,5 +1,6 @@
 import React, { useEffect, useState } from 'react';
 import { useDataProviderStore } from '../store/dataProviderStore';
+import { ccxtInstanceManager } from '../store/utils/ccxtInstanceManager';
 
 export const TestChartWidget: React.FC = () => {
   const { 
@@ -33,17 +34,33 @@ export const TestChartWidget: React.FC = () => {
     addResult(`Provider for Binance: ${binanceProvider ? binanceProvider.name : 'None'}`);
   };
 
-  const testCCXT = () => {
+  const testCCXT = async () => {
     addResult('=== Testing CCXT ===');
     try {
       const ccxt = (window as any).ccxt;
       if (ccxt) {
         addResult(`CCXT loaded: version ${ccxt.version || 'unknown'}`);
         addResult(`Available exchanges: ${Object.keys(ccxt).filter(k => typeof ccxt[k] === 'function').slice(0, 5).join(', ')}...`);
-
-        // Test Binance instance creation
-        const binance = new ccxt.binance();
-        addResult(`Binance instance created: ${binance.id}`);
+
+        // Test Binance instance creation using ccxtInstanceManager
+        try {
+          const binance = await ccxtInstanceManager.getExchangeInstanceForMarket(
+            'binance',
+            'test-account',
+            {
+              apiKey: 'test',
+              secret: 'test',
+              sandbox: true
+            },
+            'spot'
+          );
+          addResult(`✅ Binance instance created via ccxtInstanceManager: ${binance.id}`);
+        } catch (managerError) {
+          addResult(`❌ ccxtInstanceManager error: ${managerError}`);
+          // Fallback to direct instantiation for comparison
+          const binance = new ccxt.binance();
+          addResult(`⚠️ Fallback - Binance instance created directly: ${binance.id}`);
+        }
       } else {
         addResult('❌ CCXT not loaded');
       }
@@ -98,7 +115,7 @@ export const TestChartWidget: React.FC = () => {
   const runAllTests = async () => {
     setTestResults([]);
     testProviders();
-    testCCXT();
+    await testCCXT();
     await testInitializeChartData();
     await testSubscription();
     addResult('=== All Tests Completed ===');
@@ -129,8 +146,8 @@ export const TestChartWidget: React.FC = () => {
           Test Providers
         </button>
 
-        <button 
-          onClick={testCCXT}
+        <button
+          onClick={() => testCCXT()}
           className="px-4 py-2 bg-yellow-500 text-white rounded hover:bg-yellow-600"
         >
           Test CCXT

src/components/TestTimeframes.tsx

@@ -1,6 +1,7 @@
 import React, { useEffect, useState } from 'react';
 import { useDataProviderStore } from '../store/dataProviderStore';
 import { getCCXT } from '../store/utils/ccxtUtils';
+import { ccxtInstanceManager } from '../store/utils/ccxtInstanceManager';
 
 const TestTimeframes: React.FC = () => {
   const { getTimeframesForExchange } = useDataProviderStore();
@@ -10,43 +11,66 @@ const TestTimeframes: React.FC = () => {
     const testExchanges = ['binance', 'bybit', 'okx', 'kucoin'];
     const testResults: Record<string, any> = {};
 
-    // Test direct CCXT access
-    console.log('🧪 [TestTimeframes] Testing direct CCXT access');
-    const ccxt = getCCXT();
-    if (ccxt) {
-      console.log('✅ [TestTimeframes] CCXT is available');
-      console.log('📋 [TestTimeframes] Available exchanges:', Object.keys(ccxt).filter(key => typeof ccxt[key] === 'function').slice(0, 10));
-
-      // Test specific exchange
-      if (ccxt.binance) {
+    const runTests = async () => {
+      // Test direct CCXT access
+      console.log('🧪 [TestTimeframes] Testing direct CCXT access');
+      const ccxt = getCCXT();
+      if (ccxt) {
+        console.log('✅ [TestTimeframes] CCXT is available');
+        console.log('📋 [TestTimeframes] Available exchanges:', Object.keys(ccxt).filter(key => typeof ccxt[key] === 'function').slice(0, 10));
+
+        // Test specific exchange using ccxtInstanceManager
+        if (ccxt.binance) {
+          try {
+            const binanceInstance = await ccxtInstanceManager.getExchangeInstanceForMarket(
+              'binance',
+              'test-timeframes-account',
+              {
+                apiKey: 'test',
+                secret: 'test',
+                sandbox: true
+              },
+              'spot'
+            );
+            console.log('📊 [TestTimeframes] Binance timeframes via ccxtInstanceManager:', binanceInstance.timeframes);
+            testResults.binance_direct = binanceInstance.timeframes;
+          } catch (error) {
+            console.error('❌ [TestTimeframes] Error creating Binance instance via ccxtInstanceManager:', error);
+            testResults.binance_direct = { error: error.message };
+
+            // Fallback to direct instantiation for comparison
+            try {
+              const binanceInstanceFallback = new ccxt.binance();
+              console.log('⚠️ [TestTimeframes] Fallback - Binance timeframes:', binanceInstanceFallback.timeframes);
+              testResults.binance_direct = binanceInstanceFallback.timeframes;
+            } catch (fallbackError) {
+              console.error('❌ [TestTimeframes] Fallback also failed:', fallbackError);
+              testResults.binance_direct = { error: fallbackError.message };
+            }
+          }
+        }
+      } else {
+        console.error('❌ [TestTimeframes] CCXT is not available');
+        testResults.ccxt_available = false;
+      }
+
+      // Test our store method
+      testExchanges.forEach(exchange => {
+        console.log(`🧪 [TestTimeframes] Testing ${exchange}`);
         try {
-          const binanceInstance = new ccxt.binance();
-          console.log('📊 [TestTimeframes] Binance timeframes:', binanceInstance.timeframes);
-          testResults.binance_direct = binanceInstance.timeframes;
+          const timeframes = getTimeframesForExchange(exchange);
+          testResults[exchange] = timeframes;
+          console.log(`✅ [TestTimeframes] ${exchange} timeframes:`, timeframes);
         } catch (error) {
-          console.error('❌ [TestTimeframes] Error creating Binance instance:', error);
-          testResults.binance_direct = { error: error.message };
+          console.error(`❌ [TestTimeframes] Error getting timeframes for ${exchange}:`, error);
+          testResults[exchange] = { error: error.message };
         }
-      }
-    } else {
-      console.error('❌ [TestTimeframes] CCXT is not available');
-      testResults.ccxt_available = false;
-    }
-
-    // Test our store method
-    testExchanges.forEach(exchange => {
-      console.log(`🧪 [TestTimeframes] Testing ${exchange}`);
-      try {
-        const timeframes = getTimeframesForExchange(exchange);
-        testResults[exchange] = timeframes;
-        console.log(`✅ [TestTimeframes] ${exchange} timeframes:`, timeframes);
-      } catch (error) {
-        console.error(`❌ [TestTimeframes] Error getting timeframes for ${exchange}:`, error);
-        testResults[exchange] = { error: error.message };
-      }
-    });
+      });
+
+      setResults(testResults);
+    };
 
-    setResults(testResults);
+    runTests();
   }, [getTimeframesForExchange]);
 
   return (