Remove unprofitable 15m timeframe symbols (ETHUSDT & EURUSD) from the entire application

scratch/analyzeETH.js

@@ -0,0 +1,115 @@
+// scratch/analyzeETH.js
+import { fetchCandles } from '../src/data/yahooFinanceAPI.js';
+import { analyzeTrend } from '../src/analysis/trendDetector.js';
+import { detectStructure } from '../src/analysis/marketStructure.js';
+import { detectOrderBlocks, updateMitigation } from '../src/analysis/orderBlocks.js';
+import { detectZones, updateZoneStatus } from '../src/analysis/supplyDemand.js';
+import { rsi, ema, macd } from '../src/analysis/indicators.js';
+import { analyzeExit } from '../src/analysis/exitManager.js';
+
+// Polyfill fetch exactly like server.js
+const originalFetch = globalThis.fetch;
+globalThis.fetch = async (input, init) => {
+  let url = typeof input === 'string' ? input : input.url;
+
+  if (url.startsWith('/api/swissquote')) {
+    url = 'https://forex-data-feed.swissquote.com/public-quotes/bboquotes/instrument/XAU/USD';
+  } else if (url.startsWith('/api/yahoo')) {
+    url = 'https://query1.finance.yahoo.com' + url.replace(/^\/api\/yahoo/, '');
+    init = init || {};
+    init.headers = {
+      ...init.headers,
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      'Origin': 'https://finance.yahoo.com',
+      'Referer': 'https://finance.yahoo.com',
+    };
+  }
+
+  return originalFetch(url, init);
+};
+
+async function run() {
+  console.log('=== ETHUSDT Live Analysis Dashboard ===\n');
+  try {
+    const symbol = 'ETHUSDT';
+    const candles = await fetchCandles(symbol, '15m');
+    console.log(`[Market Data] Loaded ${candles.length} candles from Yahoo Finance.`);
+    
+    if (candles.length === 0) {
+      console.error('No market data loaded.');
+      return;
+    }
+
+    const latest = candles[candles.length - 1];
+    console.log(`Current Price: $${latest.close.toFixed(2)} | Time: ${new Date(latest.time * 1000).toLocaleString()}`);
+    
+    // 1. Indicators
+    const closes = candles.map(c => c.close);
+    const rsiVals = rsi(closes);
+    const ema9 = ema(closes, 9);
+    const ema21 = ema(closes, 21);
+    const ema50 = ema(closes, 50);
+    const ema200 = ema(closes, 200);
+    const macdData = macd(closes);
+
+    const lastRSI = rsiVals[rsiVals.length - 1];
+    const lastE9 = ema9[ema9.length - 1];
+    const lastE21 = ema21[ema21.length - 1];
+    const lastE50 = ema50[ema50.length - 1];
+    const lastE200 = ema200[ema200.length - 1];
+
+    console.log('\n📊 Indicators:');
+    console.log(`- RSI (14): ${lastRSI.toFixed(2)} (${lastRSI > 70 ? 'Overbought' : lastRSI < 30 ? 'Oversold' : 'Neutral'})`);
+    console.log(`- EMA 9: $${lastE9.toFixed(2)}`);
+    console.log(`- EMA 21: $${lastE21.toFixed(2)}`);
+    console.log(`- EMA 50: $${lastE50.toFixed(2)}`);
+    console.log(`- EMA 200: $${lastE200.toFixed(2)}`);
+
+    // 2. Trend & Structure
+    const trend = analyzeTrend(candles);
+    const structure = detectStructure(candles);
+    console.log('\n📈 Trend & Market Structure:');
+    console.log(`- Direction: ${trend.direction.toUpperCase()} (Strength: ${trend.strength}/100)`);
+    console.log(`- Structure Trend: ${structure.trend}`);
+    console.log(`- EMA Alignment: ${trend.emaAlignment}`);
+    console.log(`- Momentum: ${trend.momentum}`);
+
+    // 3. SMC Areas
+    let obs = detectOrderBlocks(candles);
+    obs = updateMitigation(obs, candles);
+    const activeOBs = obs.filter(o => !o.mitigated);
+    console.log(`- Active Order Blocks: ${activeOBs.length} detected.`);
+    if (activeOBs.length > 0) {
+      console.log(`  * Recent OB: Type: ${activeOBs[activeOBs.length - 1].type.toUpperCase()}, Top: $${activeOBs[activeOBs.length - 1].top.toFixed(2)}, Bottom: $${activeOBs[activeOBs.length - 1].bottom.toFixed(2)}`);
+    }
+
+    // 4. Exit Manager for User's trade
+    const userTrade = {
+      type: 'SHORT',
+      entry: 1979.05,
+      sl: 1996.46,
+      tp1: 1979.05 - (1996.46 - 1979.05) * 2, // approximate TP1 = entry - 2R
+      tp2: 1926.81,
+      lotSize: 2.87,
+      symbol: 'ETHUSDT'
+    };
+
+    const exitAnalysis = analyzeExit(candles, userTrade);
+    console.log('\n🛡️ Active Trade Analysis (SHORT ETHUSDT):');
+    console.log(`- Current Unrealized P&L: $${exitAnalysis.currentPnL.toFixed(2)}`);
+    console.log(`- Current R:R: ${exitAnalysis.currentRR.toFixed(2)}`);
+    console.log(`- Suggestion: ${exitAnalysis.suggestion}`);
+    console.log(`- Recommendation: ${exitAnalysis.reason}`);
+    if (exitAnalysis.warnings && exitAnalysis.warnings.length > 0) {
+      console.log('- Warnings:');
+      exitAnalysis.warnings.forEach(w => console.log(`  * ⚠️ ${w}`));
+    } else {
+      console.log('- Warnings: None (normal parameters)');
+    }
+
+  } catch (err) {
+    console.error('Analysis failed:', err);
+  }
+}
+
+run();

scratch/backtestSignals.js

@@ -0,0 +1,234 @@
+// backtestSignals.js
+import { fetchCandles } from '../src/data/yahooFinanceAPI.js';
+import { generateSignals } from '../src/analysis/signalGenerator.js';
+
+// Polyfill fetch exactly like server.js
+const originalFetch = globalThis.fetch;
+globalThis.fetch = async (input, init) => {
+  let url = typeof input === 'string' ? input : input.url;
+
+  if (url.startsWith('/api/swissquote')) {
+    url = 'https://forex-data-feed.swissquote.com/public-quotes/bboquotes/instrument/XAU/USD';
+  } else if (url.startsWith('/api/yahoo')) {
+    url = 'https://query1.finance.yahoo.com' + url.replace(/^\/api\/yahoo/, '');
+    init = init || {};
+    init.headers = {
+      ...init.headers,
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      'Origin': 'https://finance.yahoo.com',
+      'Referer': 'https://finance.yahoo.com',
+    };
+  }
+
+  return originalFetch(url, init);
+};
+
+function calculatePnL(symbol, type, entry, exit, lots) {
+  const direction = type === 'LONG' ? 1 : -1;
+  const diff = (exit - entry) * direction;
+  if (symbol === 'BTCUSDT' || symbol === 'ETHUSDT') {
+    return diff * lots;
+  } else if (symbol === 'XAUUSD') {
+    return diff * lots * 100;
+  } else if (symbol === 'EURUSD' || symbol === 'GBPUSD' || symbol === 'USDCAD') {
+    const rate = symbol === 'USDCAD' ? 1.38 : 1.0; // approximation for USDCAD USD-conversion
+    const pipScale = symbol === 'USDCAD' ? (10 / rate) : 10;
+    return (diff / 0.0001) * lots * pipScale;
+  }
+  return 0;
+}
+
+function calculateCommission(symbol, entryPrice, lots) {
+  if (symbol === 'BTCUSDT' || symbol === 'ETHUSDT') {
+    return 0.0008 * entryPrice * lots;
+  } else {
+    return 5.0 * lots;
+  }
+}
+
+function getSpread(symbol) {
+  switch (symbol) {
+    case 'BTCUSDT': return 25.0;
+    case 'ETHUSDT': return 5.0;
+    case 'XAUUSD': return 0.7;
+    case 'EURUSD':
+    case 'GBPUSD':
+    case 'USDCAD':
+      return 0.00007;
+    default:
+      return 0;
+  }
+}
+
+function backtestTrade(symbol, signal, candles, startIndex) {
+  let partialClosed = false;
+  let sl = signal.sl;
+  let entry = signal.entry;
+  let lots = signal.lotSize;
+  let commission = calculateCommission(symbol, entry, lots);
+  const spread = getSpread(symbol);
+  
+  for (let c = startIndex; c < candles.length; c++) {
+    const candle = candles[c];
+    
+    if (signal.type === 'LONG') {
+      // Check SL hit
+      if (candle.low <= sl) {
+        if (!partialClosed) {
+          // Full SL hit
+          const pnl = calculatePnL(symbol, 'LONG', entry, sl, lots) - commission;
+          return { status: 'LOSS', pnl, exitTime: candle.time, exitPrice: sl };
+        } else {
+          // Stopped out at breakeven (entry) on remaining 30%
+          const tp1PnL = calculatePnL(symbol, 'LONG', entry, signal.tp1, lots * 0.7);
+          const pnl = tp1PnL - commission;
+          return { status: 'PARTIAL_STOP', pnl, exitTime: candle.time, exitPrice: sl };
+        }
+      }
+      
+      // Check TP1 hit
+      if (!partialClosed && candle.high >= signal.tp1) {
+        partialClosed = true;
+        sl = entry; // Trail SL to breakeven
+      }
+      
+      // Check TP2 hit
+      if (partialClosed && candle.high >= signal.tp2) {
+        const tp1PnL = calculatePnL(symbol, 'LONG', entry, signal.tp1, lots * 0.7);
+        const tp2PnL = calculatePnL(symbol, 'LONG', entry, signal.tp2, lots * 0.3);
+        const pnl = tp1PnL + tp2PnL - commission;
+        return { status: 'WIN', pnl, exitTime: candle.time, exitPrice: signal.tp2 };
+      }
+    } else {
+      // SHORT: exits occur at Ask price = chart price + spread
+      // Check SL hit
+      if (candle.high + spread >= sl) {
+        if (!partialClosed) {
+          const pnl = calculatePnL(symbol, 'SHORT', entry, sl, lots) - commission;
+          return { status: 'LOSS', pnl, exitTime: candle.time, exitPrice: sl };
+        } else {
+          const tp1PnL = calculatePnL(symbol, 'SHORT', entry, signal.tp1, lots * 0.7);
+          const pnl = tp1PnL - commission;
+          return { status: 'PARTIAL_STOP', pnl, exitTime: candle.time, exitPrice: sl };
+        }
+      }
+      
+      // Check TP1 hit
+      if (!partialClosed && candle.low + spread <= signal.tp1) {
+        partialClosed = true;
+        sl = entry; // Trail SL to breakeven
+      }
+      
+      // Check TP2 hit
+      if (partialClosed && candle.low + spread <= signal.tp2) {
+        const tp1PnL = calculatePnL(symbol, 'SHORT', entry, signal.tp1, lots * 0.7);
+        const tp2PnL = calculatePnL(symbol, 'SHORT', entry, signal.tp2, lots * 0.3);
+        const pnl = tp1PnL + tp2PnL - commission;
+        return { status: 'WIN', pnl, exitTime: candle.time, exitPrice: signal.tp2 };
+      }
+    }
+  }
+  
+  // Trade still open at end of history
+  const lastCandle = candles[candles.length - 1];
+  const valuation = lastCandle.close;
+  if (!partialClosed) {
+    const valuationPrice = signal.type === 'SHORT' ? valuation + spread : valuation;
+    const pnl = calculatePnL(symbol, signal.type, entry, valuationPrice, lots) - commission;
+    return { status: 'OPEN', pnl, exitTime: lastCandle.time, exitPrice: valuationPrice };
+  } else {
+    const valuationPrice = signal.type === 'SHORT' ? valuation + spread : valuation;
+    const tp1PnL = calculatePnL(symbol, signal.type, entry, signal.tp1, lots * 0.7);
+    const tp2PnL = calculatePnL(symbol, signal.type, entry, valuationPrice, lots * 0.3);
+    const pnl = tp1PnL + tp2PnL - commission;
+    return { status: 'OPEN_PARTIAL', pnl, exitTime: lastCandle.time, exitPrice: valuationPrice };
+  }
+}
+
+const SYMBOLS = ['BTCUSDT', 'ETHUSDT', 'XAUUSD', 'GBPUSD', 'EURUSD', 'USDCAD'];
+
+async function runBacktest() {
+  console.log('=== RUNNING HISTORICAL BACKTEST & QUALITY METRICS ===');
+  console.log('Parameters: 1H Timeframe, Spread & Commission Enabled, TP1 (70%) + BE SL Trailing\n');
+  
+  for (const symbol of SYMBOLS) {
+    try {
+      const candles = await fetchCandles(symbol, '1H');
+      if (!candles || candles.length < 100) {
+        console.log(`[${symbol}] Insufficient data for backtest.`);
+        continue;
+      }
+      
+      let totalTrades = 0;
+      let fullWins = 0; // Hit TP2
+      let partialWins = 0; // Hit TP1, then stopped at BE
+      let fullLosses = 0; // Hit SL before TP1
+      let openTrades = 0;
+      let totalPnL = 0;
+      
+      // Let's slide a window through historical candles
+      // To simulate real execution, we keep a cooldown timer per symbol
+      let lastClosedTime = 0;
+      let isCooldown = false;
+      let activeTradeEndIndex = -1;
+      
+      for (let i = 50; i < candles.length; i++) {
+        // Check if there is an active trade running
+        if (i <= activeTradeEndIndex) {
+          continue; // skip scanning if in a trade
+        }
+        
+        // Check cooldown (10 minutes = 1 candle on 15m TF)
+        if (lastClosedTime > 0 && (candles[i].time - lastClosedTime) < 600) {
+          continue; // skip scanning if cooling down
+        }
+        
+        const window = candles.slice(0, i);
+        const signals = generateSignals(window, symbol, 0);
+        
+        // Filter signals to Grade A and B
+        const validSignals = signals.filter(sig => ['A', 'B'].includes(sig.quality));
+        if (validSignals.length === 0) continue;
+        
+        const signal = validSignals[0];
+        // We evaluate the trade outcome starting from candle index `i` (entry is at the close of candle `i-1`)
+        const result = backtestTrade(symbol, signal, candles, i);
+        
+        totalTrades++;
+        totalPnL += result.pnl;
+        
+        // Estimate index of trade exit
+        let exitIndex = candles.findIndex(c => c.time === result.exitTime);
+        if (exitIndex === -1) exitIndex = candles.length - 1;
+        
+        activeTradeEndIndex = exitIndex;
+        lastClosedTime = result.exitTime;
+        
+        if (result.status === 'WIN') fullWins++;
+        else if (result.status === 'PARTIAL_STOP') partialWins++;
+        else if (result.status === 'LOSS') fullLosses++;
+        else openTrades++;
+      }
+      
+      const completedTrades = fullWins + partialWins + fullLosses;
+      const winRate = completedTrades > 0 ? ((fullWins + partialWins) / completedTrades) * 100 : 0;
+      const fullWinRate = completedTrades > 0 ? (fullWins / completedTrades) * 100 : 0;
+      const avgPnL = completedTrades > 0 ? totalPnL / completedTrades : 0;
+      
+      console.log(`[${symbol}] Backtest results over ${candles.length} candles (~${Math.round(candles.length / 96)} days):`);
+      console.log(`   Total Scanned Signals Executed: ${totalTrades}`);
+      console.log(`   Completed Outcomes: ${completedTrades} (Open: ${openTrades})`);
+      console.log(`   - Hit TP2 (Full Win): ${fullWins} (${fullWinRate.toFixed(1)}%)`);
+      console.log(`   - Hit TP1, then BE Stop (Partial Profit): ${partialWins}`);
+      console.log(`   - Hit SL (Full Loss): ${fullLosses}`);
+      console.log(`   - Net Win Rate (Profit/BE Trades): ${winRate.toFixed(1)}%`);
+      console.log(`   - Total Cumulative Net P&L: $${totalPnL.toFixed(2)}`);
+      console.log(`   - Average P&L per completed trade: $${avgPnL.toFixed(2)}\n`);
+      
+    } catch (e) {
+      console.error(`Error backtesting ${symbol}:`, e.message);
+    }
+  }
+}
+
+runBacktest();

scratch/checkAllTimeframes.js

@@ -0,0 +1,71 @@
+// checkAllTimeframes.js
+const originalFetch = globalThis.fetch;
+globalThis.fetch = async (input, init) => {
+  let url = typeof input === 'string' ? input : input.url;
+  if (url.startsWith('/api/yahoo')) {
+    url = 'https://query1.finance.yahoo.com' + url.replace(/^\/api\/yahoo/, '');
+    init = init || {};
+    init.headers = {
+      ...init.headers,
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      'Origin': 'https://finance.yahoo.com',
+      'Referer': 'https://finance.yahoo.com',
+    };
+  }
+  return originalFetch(url, init);
+};
+
+const TIMEFRAMES = {
+  '1m': { interval: '1m', range: '1d' },
+  '5m': { interval: '5m', range: '5d' },
+  '15m': { interval: '15m', range: '15d' },
+  '1H': { interval: '60m', range: '30d' },
+  '1D': { interval: '1d', range: '1y' }
+};
+
+async function test() {
+  for (const [tf, config] of Object.entries(TIMEFRAMES)) {
+    const url = `https://query1.finance.yahoo.com/v8/finance/chart/USDCAD=X?interval=${config.interval}&range=${config.range}`;
+    try {
+      const res = await fetch(url);
+      const data = await res.json();
+      const result = data.chart.result[0];
+      if (!result || !result.timestamp) {
+        console.log(`Timeframe ${tf}: No data`);
+        continue;
+      }
+      const timestamps = result.timestamp;
+      const quotes = result.indicators.quote[0];
+      
+      let maxWick = 0;
+      let maxWickTime = null;
+      let count = 0;
+
+      for (let i = 0; i < timestamps.length; i++) {
+        const o = quotes.open[i];
+        const h = quotes.high[i];
+        const l = quotes.low[i];
+        const c = quotes.close[i];
+        if (o === null || h === null || l === null || c === null) continue;
+
+        count++;
+        const maxBody = Math.max(o, c);
+        const minBody = Math.min(o, c);
+        const upper = h - maxBody;
+        const lower = minBody - l;
+        const wick = Math.max(upper, lower);
+
+        if (wick > maxWick) {
+          maxWick = wick;
+          maxWickTime = new Date(timestamps[i] * 1000).toLocaleString();
+        }
+      }
+
+      console.log(`Timeframe ${tf}: Total candles=${count}, Max Wick=${maxWick.toFixed(5)} (${Math.round(maxWick * 10000)} pips) at ${maxWickTime}`);
+    } catch (e) {
+      console.log(`Timeframe ${tf}: Failed with error: ${e.message}`);
+    }
+  }
+}
+
+test();

scratch/checkForexVolume.js

@@ -0,0 +1,42 @@
+// checkForexVolume.js
+import { fetchCandles } from '../src/data/yahooFinanceAPI.js';
+
+// Polyfill fetch exactly like server.js
+const originalFetch = globalThis.fetch;
+globalThis.fetch = async (input, init) => {
+  let url = typeof input === 'string' ? input : input.url;
+
+  if (url.startsWith('/api/swissquote')) {
+    url = 'https://forex-data-feed.swissquote.com/public-quotes/bboquotes/instrument/XAU/USD';
+  } else if (url.startsWith('/api/yahoo')) {
+    url = 'https://query1.finance.yahoo.com' + url.replace(/^\/api\/yahoo/, '');
+    init = init || {};
+    init.headers = {
+      ...init.headers,
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      'Origin': 'https://finance.yahoo.com',
+      'Referer': 'https://finance.yahoo.com',
+    };
+  }
+
+  return originalFetch(url, init);
+};
+
+async function test() {
+  const symbols = ['EURUSD', 'GBPUSD', 'USDCAD', 'XAUUSD', 'BTCUSDT', 'ETHUSDT'];
+  for (const sym of symbols) {
+    try {
+      const candles = await fetchCandles(sym, '15m');
+      const sample = candles.slice(-5);
+      console.log(`\n=== Symbol: ${sym} ===`);
+      console.log(`Total candles loaded: ${candles.length}`);
+      sample.forEach(c => {
+        console.log(`Candle Time: ${new Date(c.time * 1000).toLocaleString()} | Close: ${c.close} | Volume: ${c.volume}`);
+      });
+    } catch (e) {
+      console.error(`Error for ${sym}:`, e.message);
+    }
+  }
+}
+
+test();

scratch/findWicks.js

@@ -0,0 +1,76 @@
+import { fetchCandles } from '../src/data/yahooFinanceAPI.js';
+
+// Polyfill fetch
+const originalFetch = globalThis.fetch;
+globalThis.fetch = async (input, init) => {
+  let url = typeof input === 'string' ? input : input.url;
+  if (url.startsWith('/api/yahoo')) {
+    url = 'https://query1.finance.yahoo.com' + url.replace(/^\/api\/yahoo/, '');
+    init = init || {};
+    init.headers = {
+      ...init.headers,
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      'Origin': 'https://finance.yahoo.com',
+      'Referer': 'https://finance.yahoo.com',
+    };
+  }
+  return originalFetch(url, init);
+};
+
+async function check() {
+  const symbol = 'USDCAD';
+  console.log(`--- Fetching ${symbol} from Yahoo Finance ---`);
+  const url = 'https://query1.finance.yahoo.com/v8/finance/chart/USDCAD=X?interval=15m&range=15d';
+  const res = await fetch(url);
+  const data = await res.json();
+  const result = data.chart.result[0];
+  const timestamps = result.timestamp;
+  const quotes = result.indicators.quote[0];
+
+  console.log(`Total timestamps: ${timestamps.length}`);
+  
+  let nonNullCount = 0;
+  let minLow = Infinity;
+  let maxHigh = -Infinity;
+  let maxWick = 0;
+  let maxWickIdx = -1;
+
+  for (let i = 0; i < timestamps.length; i++) {
+    const o = quotes.open[i];
+    const h = quotes.high[i];
+    const l = quotes.low[i];
+    const c = quotes.close[i];
+    if (o === null || h === null || l === null || c === null) continue;
+
+    nonNullCount++;
+    if (l < minLow) minLow = l;
+    if (h > maxHigh) maxHigh = h;
+
+    const maxBody = Math.max(o, c);
+    const minBody = Math.min(o, c);
+    const upperWick = h - maxBody;
+    const lowerWick = minBody - l;
+    const wick = Math.max(upperWick, lowerWick);
+
+    if (wick > maxWick) {
+      maxWick = wick;
+      maxWickIdx = i;
+    }
+  }
+
+  console.log(`Non-null quotes: ${nonNullCount}`);
+  console.log(`Absolute Min Low: ${minLow}`);
+  console.log(`Absolute Max High: ${maxHigh}`);
+  console.log(`Max Wick size: ${maxWick} at index ${maxWickIdx}`);
+  if (maxWickIdx !== -1) {
+    console.log('Candle with max wick:', {
+      time: new Date(timestamps[maxWickIdx] * 1000).toLocaleString(),
+      open: quotes.open[maxWickIdx],
+      high: quotes.high[maxWickIdx],
+      low: quotes.low[maxWickIdx],
+      close: quotes.close[maxWickIdx]
+    });
+  }
+}
+
+check();

scratch/highFidelityBacktest.js

@@ -0,0 +1,251 @@
+import { fetchCandles } from '../src/data/yahooFinanceAPI.js';
+import { generateSignals } from '../src/analysis/signalGenerator.js';
+
+// Polyfill fetch exactly like server.js
+const originalFetch = globalThis.fetch;
+globalThis.fetch = async (input, init) => {
+  let url = typeof input === 'string' ? input : input.url;
+  if (url.startsWith('/api/swissquote')) {
+    url = 'https://forex-data-feed.swissquote.com/public-quotes/bboquotes/instrument/XAU/USD';
+  } else if (url.startsWith('/api/yahoo')) {
+    url = 'https://query1.finance.yahoo.com' + url.replace(/^\/api\/yahoo/, '');
+    init = init || {};
+    init.headers = {
+      ...init.headers,
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      'Origin': 'https://finance.yahoo.com',
+      'Referer': 'https://finance.yahoo.com',
+    };
+  }
+  return originalFetch(url, init);
+};
+
+function getSpread(symbol) {
+  switch (symbol) {
+    case 'BTCUSDT': return 25.0;
+    case 'ETHUSDT': return 5.0;
+    case 'XAUUSD': return 0.7;
+    case 'EURUSD':
+    case 'GBPUSD':
+    case 'USDCAD':
+      return 0.00007;
+    default:
+      return 0;
+  }
+}
+
+function calculatePnL(symbol, type, entry, exit, lots) {
+  const direction = type === 'LONG' ? 1 : -1;
+  const diff = (exit - entry) * direction;
+  if (symbol === 'BTCUSDT' || symbol === 'ETHUSDT') {
+    return diff * lots;
+  } else if (symbol === 'XAUUSD') {
+    return diff * lots * 100;
+  } else if (symbol === 'EURUSD' || symbol === 'GBPUSD' || symbol === 'USDCAD') {
+    const rate = symbol === 'USDCAD' ? 1.38 : 1.0;
+    const pipScale = symbol === 'USDCAD' ? (10 / rate) : 10;
+    return (diff / 0.0001) * lots * pipScale;
+  }
+  return 0;
+}
+
+function calculateCommission(symbol, entryPrice, lots) {
+  if (symbol === 'BTCUSDT' || symbol === 'ETHUSDT') {
+    return 0.0008 * entryPrice * lots;
+  } else {
+    return 5.0 * lots;
+  }
+}
+
+/**
+ * Runs high-fidelity exit check using lower timeframe candles.
+ */
+function checkExitHighFidelity(symbol, signal, lowerCandles, startLtIndex) {
+  let partialClosed = false;
+  let sl = signal.sl;
+  let entry = signal.entry;
+  let lots = signal.lotSize;
+  let commission = calculateCommission(symbol, entry, lots);
+  const spread = getSpread(symbol);
+
+  for (let c = startLtIndex; c < lowerCandles.length; c++) {
+    const candle = lowerCandles[c];
+
+    if (signal.type === 'LONG') {
+      // Check SL hit
+      if (candle.low <= sl) {
+        if (!partialClosed) {
+          const pnl = calculatePnL(symbol, 'LONG', entry, sl, lots) - commission;
+          return { status: 'LOSS', pnl, exitTime: candle.time, exitPrice: sl };
+        } else {
+          const tp1PnL = calculatePnL(symbol, 'LONG', entry, signal.tp1, lots * 0.7);
+          const pnl = tp1PnL - commission;
+          return { status: 'PARTIAL_STOP', pnl, exitTime: candle.time, exitPrice: sl };
+        }
+      }
+      
+      // Check TP1 hit
+      if (!partialClosed && candle.high >= signal.tp1) {
+        partialClosed = true;
+        sl = entry;
+      }
+      
+      // Check TP2 hit
+      if (partialClosed && candle.high >= signal.tp2) {
+        const tp1PnL = calculatePnL(symbol, 'LONG', entry, signal.tp1, lots * 0.7);
+        const tp2PnL = calculatePnL(symbol, 'LONG', entry, signal.tp2, lots * 0.3);
+        const pnl = tp1PnL + tp2PnL - commission;
+        return { status: 'WIN', pnl, exitTime: candle.time, exitPrice: signal.tp2 };
+      }
+    } else {
+      // SHORT
+      if (candle.high + spread >= sl) {
+        if (!partialClosed) {
+          const pnl = calculatePnL(symbol, 'SHORT', entry, sl, lots) - commission;
+          return { status: 'LOSS', pnl, exitTime: candle.time, exitPrice: sl };
+        } else {
+          const tp1PnL = calculatePnL(symbol, 'SHORT', entry, signal.tp1, lots * 0.7);
+          const pnl = tp1PnL - commission;
+          return { status: 'PARTIAL_STOP', pnl, exitTime: candle.time, exitPrice: sl };
+        }
+      }
+      
+      if (!partialClosed && candle.low + spread <= signal.tp1) {
+        partialClosed = true;
+        sl = entry;
+      }
+      
+      if (partialClosed && candle.low + spread <= signal.tp2) {
+        const tp1PnL = calculatePnL(symbol, 'SHORT', entry, signal.tp1, lots * 0.7);
+        const tp2PnL = calculatePnL(symbol, 'SHORT', entry, signal.tp2, lots * 0.3);
+        const pnl = tp1PnL + tp2PnL - commission;
+        return { status: 'WIN', pnl, exitTime: candle.time, exitPrice: signal.tp2 };
+      }
+    }
+  }
+
+  // Still open
+  const lastCandle = lowerCandles[lowerCandles.length - 1];
+  const valuation = lastCandle.close;
+  if (!partialClosed) {
+    const valuationPrice = signal.type === 'SHORT' ? valuation + spread : valuation;
+    const pnl = calculatePnL(symbol, signal.type, entry, valuationPrice, lots) - commission;
+    return { status: 'OPEN', pnl, exitTime: lastCandle.time, exitPrice: valuationPrice };
+  } else {
+    const valuationPrice = signal.type === 'SHORT' ? valuation + spread : valuation;
+    const tp1PnL = calculatePnL(symbol, signal.type, entry, signal.tp1, lots * 0.7);
+    const tp2PnL = calculatePnL(symbol, signal.type, entry, valuationPrice, lots * 0.3);
+    const pnl = tp1PnL + tp2PnL - commission;
+    return { status: 'OPEN_PARTIAL', pnl, exitTime: lastCandle.time, exitPrice: valuationPrice };
+  }
+}
+
+const SYMBOLS = ['BTCUSDT', 'ETHUSDT', 'XAUUSD', 'GBPUSD', 'EURUSD', 'USDCAD'];
+
+async function runHighFidelityBacktest(signalTimeframe) {
+  console.log(`\n=== RUNNING HIGH-FIDELITY BACKTEST (Signals: ${signalTimeframe}, Exits checked on: 5m candles) ===`);
+  
+  // Fetch lower timeframe candles for exit checking (range 30d for 5m is supported by Yahoo)
+  // Let's modify TIMEFRAME_CONFIG dynamically inside yahooFinanceAPI to make sure GC=F and others return 30d of 5m
+  // We can just query directly or fetch it.
+  
+  for (const symbol of SYMBOLS) {
+    try {
+      const sigCandles = await fetchCandles(symbol, signalTimeframe);
+      // Fetch 5m candles to track entries/exits at fine resolution
+      // We temporarily fetch with '5m' timeframe. Let's make sure it returns enough candles.
+      const ltCandles = await fetchCandles(symbol, '5m');
+      
+      if (!sigCandles || sigCandles.length < 100 || !ltCandles || ltCandles.length < 100) {
+        console.log(`[${symbol}] Insufficient candles. Signal Count: ${sigCandles?.length}, 5m Count: ${ltCandles?.length}`);
+        continue;
+      }
+
+      let totalTrades = 0;
+      let fullWins = 0;
+      let partialWins = 0;
+      let fullLosses = 0;
+      let openTrades = 0;
+      let totalPnL = 0;
+      
+      let lastClosedTime = 0;
+      let activeTradeEndIndex = -1; // index in sigCandles
+      let activeTradeEndLtTime = 0;
+
+      for (let i = 50; i < sigCandles.length; i++) {
+        // Skip scanning if we are currently inside an active trade (using time constraint)
+        if (sigCandles[i].time <= activeTradeEndLtTime) {
+          continue;
+        }
+
+        // Cooldown check (10 minutes)
+        if (lastClosedTime > 0 && (sigCandles[i].time - lastClosedTime) < 600) {
+          continue;
+        }
+
+        const window = sigCandles.slice(0, i);
+        const signals = generateSignals(window, symbol, 0);
+        const validSignals = signals.filter(sig => ['A', 'B'].includes(sig.quality));
+        if (validSignals.length === 0) continue;
+
+        const signal = validSignals[0];
+        
+        // Find corresponding index in the lower-timeframe 5m candles
+        // Entry is at the close of candle i-1, which is the start of candle i
+        const entryTime = sigCandles[i].time;
+        let ltIndex = ltCandles.findIndex(c => c.time >= entryTime);
+        if (ltIndex === -1) continue;
+
+        const result = checkExitHighFidelity(symbol, signal, ltCandles, ltIndex);
+
+        totalTrades++;
+        totalPnL += result.pnl;
+
+        if (result.status === 'WIN') fullWins++;
+        else if (result.status === 'PARTIAL_STOP') partialWins++;
+        else if (result.status === 'LOSS') fullLosses++;
+        else openTrades++;
+
+        activeTradeEndLtTime = result.exitTime;
+        lastClosedTime = result.exitTime;
+      }
+
+      const completedTrades = fullWins + partialWins + fullLosses;
+      const winRate = completedTrades > 0 ? ((fullWins + partialWins) / completedTrades) * 100 : 0;
+      const fullWinRate = completedTrades > 0 ? (fullWins / completedTrades) * 100 : 0;
+      const avgPnL = completedTrades > 0 ? totalPnL / completedTrades : 0;
+
+      console.log(`[${symbol}] Results over ~10-15 days of overlap:`);
+      console.log(`   Total Scanned Signals Executed: ${totalTrades}`);
+      console.log(`   Completed Outcomes: ${completedTrades} (Open: ${openTrades})`);
+      console.log(`   - Hit TP2 (Full Win): ${fullWins} (${fullWinRate.toFixed(1)}%)`);
+      console.log(`   - Hit TP1, then BE Stop (Partial Profit): ${partialWins}`);
+      console.log(`   - Hit SL (Full Loss): ${fullLosses}`);
+      console.log(`   - Net Win Rate (Profit/BE Trades): ${winRate.toFixed(1)}%`);
+      console.log(`   - Total Cumulative Net P&L: $${totalPnL.toFixed(2)}`);
+      console.log(`   - Average P&L per completed trade: $${avgPnL.toFixed(2)}\n`);
+
+    } catch (e) {
+      console.error(`Error backtesting ${symbol}:`, e.message);
+    }
+  }
+}
+
+async function run() {
+  // Let's modify TIMEFRAME_CONFIG range for 5m to 30d so we have enough candles to overlap with 1H's 60d
+  // We will patch the config dynamically
+  try {
+    const { TIMEFRAME_CONFIG } = await import('../src/data/yahooFinanceAPI.js');
+    if (TIMEFRAME_CONFIG && TIMEFRAME_CONFIG['5m']) {
+      TIMEFRAME_CONFIG['5m'].range = '30d';
+      console.log('[Info] Dynamically expanded 5m Yahoo range to 30d.');
+    }
+  } catch (err) {
+    // Ignore
+  }
+
+  await runHighFidelityBacktest('15m');
+  await runHighFidelityBacktest('1H');
+}
+
+run();

scratch/optimizeParams.js

@@ -0,0 +1,195 @@
+import { fetchCandles } from '../src/data/yahooFinanceAPI.js';
+import { generateSignals, ATR_MULTIPLIERS, ATR_CONFIG } from '../src/analysis/signalGenerator.js';
+
+// Polyfill fetch exactly like server.js
+const originalFetch = globalThis.fetch;
+globalThis.fetch = async (input, init) => {
+  let url = typeof input === 'string' ? input : input.url;
+  if (url.startsWith('/api/swissquote')) {
+    url = 'https://forex-data-feed.swissquote.com/public-quotes/bboquotes/instrument/XAU/USD';
+  } else if (url.startsWith('/api/yahoo')) {
+    url = 'https://query1.finance.yahoo.com' + url.replace(/^\/api\/yahoo/, '');
+    init = init || {};
+    init.headers = {
+      ...init.headers,
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      'Origin': 'https://finance.yahoo.com',
+      'Referer': 'https://finance.yahoo.com',
+    };
+  }
+  return originalFetch(url, init);
+};
+
+function getSpread(symbol) {
+  switch (symbol) {
+    case 'BTCUSDT': return 25.0;
+    case 'ETHUSDT': return 5.0;
+    case 'XAUUSD': return 0.7;
+    case 'EURUSD':
+    case 'GBPUSD':
+    case 'USDCAD':
+      return 0.00007;
+    default:
+      return 0;
+  }
+}
+
+function calculatePnL(symbol, type, entry, exit, lots) {
+  const direction = type === 'LONG' ? 1 : -1;
+  const diff = (exit - entry) * direction;
+  if (symbol === 'BTCUSDT' || symbol === 'ETHUSDT') {
+    return diff * lots;
+  } else if (symbol === 'XAUUSD') {
+    return diff * lots * 100;
+  } else if (symbol === 'EURUSD' || symbol === 'GBPUSD' || symbol === 'USDCAD') {
+    const rate = symbol === 'USDCAD' ? 1.38 : 1.0;
+    const pipScale = symbol === 'USDCAD' ? (10 / rate) : 10;
+    return (diff / 0.0001) * lots * pipScale;
+  }
+  return 0;
+}
+
+function calculateCommission(symbol, entryPrice, lots) {
+  if (symbol === 'BTCUSDT' || symbol === 'ETHUSDT') {
+    return 0.0008 * entryPrice * lots;
+  } else {
+    return 5.0 * lots;
+  }
+}
+
+function backtestTrade(symbol, signal, candles, startIndex) {
+  let partialClosed = false;
+  let sl = signal.sl;
+  let entry = signal.entry;
+  let lots = signal.lotSize;
+  let commission = calculateCommission(symbol, entry, lots);
+  const spread = getSpread(symbol);
+  
+  for (let c = startIndex; c < candles.length; c++) {
+    const candle = candles[c];
+    if (signal.type === 'LONG') {
+      if (candle.low <= sl) {
+        if (!partialClosed) {
+          const pnl = calculatePnL(symbol, 'LONG', entry, sl, lots) - commission;
+          return { status: 'LOSS', pnl, exitTime: candle.time };
+        } else {
+          const tp1PnL = calculatePnL(symbol, 'LONG', entry, signal.tp1, lots * 0.7);
+          const pnl = tp1PnL - commission;
+          return { status: 'PARTIAL_STOP', pnl, exitTime: candle.time };
+        }
+      }
+      if (!partialClosed && candle.high >= signal.tp1) {
+        partialClosed = true;
+        sl = entry;
+      }
+      if (partialClosed && candle.high >= signal.tp2) {
+        const tp1PnL = calculatePnL(symbol, 'LONG', entry, signal.tp1, lots * 0.7);
+        const tp2PnL = calculatePnL(symbol, 'LONG', entry, signal.tp2, lots * 0.3);
+        const pnl = tp1PnL + tp2PnL - commission;
+        return { status: 'WIN', pnl, exitTime: candle.time };
+      }
+    } else {
+      if (candle.high + spread >= sl) {
+        if (!partialClosed) {
+          const pnl = calculatePnL(symbol, 'SHORT', entry, sl, lots) - commission;
+          return { status: 'LOSS', pnl, exitTime: candle.time };
+        } else {
+          const tp1PnL = calculatePnL(symbol, 'SHORT', entry, signal.tp1, lots * 0.7);
+          const pnl = tp1PnL - commission;
+          return { status: 'PARTIAL_STOP', pnl, exitTime: candle.time };
+        }
+      }
+      if (!partialClosed && candle.low + spread <= signal.tp1) {
+        partialClosed = true;
+        sl = entry;
+      }
+      if (partialClosed && candle.low + spread <= signal.tp2) {
+        const tp1PnL = calculatePnL(symbol, 'SHORT', entry, signal.tp1, lots * 0.7);
+        const tp2PnL = calculatePnL(symbol, 'SHORT', entry, signal.tp2, lots * 0.3);
+        const pnl = tp1PnL + tp2PnL - commission;
+        return { status: 'WIN', pnl, exitTime: candle.time };
+      }
+    }
+  }
+  const lastCandle = candles[candles.length - 1];
+  const valuation = lastCandle.close;
+  if (!partialClosed) {
+    const valuationPrice = signal.type === 'SHORT' ? valuation + spread : valuation;
+    const pnl = calculatePnL(symbol, signal.type, entry, valuationPrice, lots) - commission;
+    return { status: 'OPEN', pnl, exitTime: lastCandle.time };
+  } else {
+    const valuationPrice = signal.type === 'SHORT' ? valuation + spread : valuation;
+    const tp1PnL = calculatePnL(symbol, signal.type, entry, signal.tp1, lots * 0.7);
+    const tp2PnL = calculatePnL(symbol, signal.type, entry, valuationPrice, lots * 0.3);
+    const pnl = tp1PnL + tp2PnL - commission;
+    return { status: 'OPEN_PARTIAL', pnl, exitTime: lastCandle.time };
+  }
+}
+
+const SYMBOLS = ['BTCUSDT', 'ETHUSDT', 'XAUUSD', 'GBPUSD', 'EURUSD', 'USDCAD'];
+const ATR_MULTIPLIERS_TO_TEST = [0.5, 1.0, 1.5, 2.0, 2.5];
+
+async function runOptimization() {
+  ATR_CONFIG.useDynamic = false;
+  const timeframes = ['15m', '1H'];
+  const data = {};
+
+  // Pre-load candles
+  for (const tf of timeframes) {
+    data[tf] = {};
+    for (const sym of SYMBOLS) {
+      data[tf][sym] = await fetchCandles(sym, tf);
+    }
+  }
+
+  for (const tf of timeframes) {
+    console.log(`\n======================= TIMEFRAME: ${tf} =======================`);
+    for (const symbol of SYMBOLS) {
+      console.log(`\n--- Symbol: ${symbol} ---`);
+      const candles = data[tf][symbol];
+      if (!candles || candles.length < 100) continue;
+
+      for (const multiplier of ATR_MULTIPLIERS_TO_TEST) {
+        // Mutate the global config object
+        ATR_MULTIPLIERS[symbol] = multiplier;
+
+        let totalPnL = 0;
+        let totalTrades = 0;
+        let wins = 0;
+        let activeTradeEndIndex = -1;
+        let lastClosedTime = 0;
+
+        for (let i = 50; i < candles.length; i++) {
+          if (i <= activeTradeEndIndex) continue;
+          if (lastClosedTime > 0 && (candles[i].time - lastClosedTime) < (tf === '15m' ? 600 : 3600)) {
+            continue;
+          }
+
+          const window = candles.slice(0, i);
+          const signals = generateSignals(window, symbol, 0);
+          const validSignals = signals.filter(sig => ['A', 'B'].includes(sig.quality));
+          if (validSignals.length === 0) continue;
+
+          const signal = validSignals[0];
+          const result = backtestTrade(symbol, signal, candles, i);
+
+          totalTrades++;
+          totalPnL += result.pnl;
+          if (result.status === 'WIN' || result.status === 'PARTIAL_STOP') {
+            wins++;
+          }
+
+          let exitIndex = candles.findIndex(c => c.time === result.exitTime);
+          if (exitIndex === -1) exitIndex = candles.length - 1;
+          activeTradeEndIndex = exitIndex;
+          lastClosedTime = result.exitTime;
+        }
+
+        const winRate = totalTrades > 0 ? (wins / totalTrades) * 100 : 0;
+        console.log(`ATR Mult: ${multiplier.toFixed(1)} | Trades: ${totalTrades} | WinRate: ${winRate.toFixed(1)}% | Net P&L: $${totalPnL.toFixed(2)}`);
+      }
+    }
+  }
+}
+
+runOptimization();

scratch/simulateSignals.js

@@ -0,0 +1,66 @@
+// simulateSignals.js
+import { fetchCandles } from '../src/data/yahooFinanceAPI.js';
+import { generateSignals } from '../src/analysis/signalGenerator.js';
+
+// Polyfill fetch exactly like server.js
+const originalFetch = globalThis.fetch;
+globalThis.fetch = async (input, init) => {
+  let url = typeof input === 'string' ? input : input.url;
+
+  if (url.startsWith('/api/swissquote')) {
+    url = 'https://forex-data-feed.swissquote.com/public-quotes/bboquotes/instrument/XAU/USD';
+  } else if (url.startsWith('/api/yahoo')) {
+    url = 'https://query1.finance.yahoo.com' + url.replace(/^\/api\/yahoo/, '');
+    init = init || {};
+    init.headers = {
+      ...init.headers,
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      'Origin': 'https://finance.yahoo.com',
+      'Referer': 'https://finance.yahoo.com',
+    };
+  }
+
+  return originalFetch(url, init);
+};
+
+const SYMBOLS = ['BTCUSDT', 'ETHUSDT', 'XAUUSD', 'GBPUSD', 'EURUSD', 'USDCAD'];
+
+async function simulate() {
+  console.log('=== Simulating Historical Signal Scans (Last 500 candles) ===\n');
+  
+  for (const symbol of SYMBOLS) {
+    try {
+      const candles = await fetchCandles(symbol, '15m');
+      console.log(`[${symbol}] Loaded ${candles.length} historical candles.`);
+      
+      // Let's run a backtest on the history. We'll feed a sliding window of candles to generateSignals
+      let gradeACount = 0;
+      let gradeBCount = 0;
+      
+      // Minimum history size needed is 50
+      for (let i = 50; i <= candles.length; i++) {
+        const window = candles.slice(0, i);
+        const signals = generateSignals(window, symbol, 0);
+        
+        for (const sig of signals) {
+          // If the signal is on the latest candle in the window
+          if (sig.time === window[window.length - 1].time) {
+            if (sig.quality === 'A') {
+              gradeACount++;
+              console.log(`   🎯 [Grade A] ${symbol} ${sig.type} at ${new Date(sig.time * 1000).toLocaleString()} (Score: ${sig.score})`);
+            } else if (sig.quality === 'B') {
+              gradeBCount++;
+            }
+          }
+        }
+      }
+      
+      console.log(`   -> Total Grade A (Score >= 5): ${gradeACount}`);
+      console.log(`   -> Total Grade B (Score == 4): ${gradeBCount}\n`);
+    } catch (err) {
+      console.error(`Error simulating for ${symbol}:`, err.message);
+    }
+  }
+}
+
+simulate();

scratch/testMarketDataEndpoint.js

@@ -0,0 +1,40 @@
+// testMarketDataEndpoint.js
+import { fetchCandles } from '../src/data/yahooFinanceAPI.js';
+import { filterForexOutlierWicks } from '../src/data/yahooFinanceAPI.js';
+
+// Polyfill fetch
+const originalFetch = globalThis.fetch;
+globalThis.fetch = async (input, init) => {
+  let url = typeof input === 'string' ? input : input.url;
+  if (url.startsWith('/api/yahoo')) {
+    url = 'https://query1.finance.yahoo.com' + url.replace(/^\/api\/yahoo/, '');
+    init = init || {};
+    init.headers = {
+      ...init.headers,
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      'Origin': 'https://finance.yahoo.com',
+      'Referer': 'https://finance.yahoo.com',
+    };
+  }
+  return originalFetch(url, init);
+};
+
+const SYMBOLS = ['BTCUSDT', 'ETHUSDT', 'XAUUSD', 'GBPUSD', 'EURUSD', 'USDCAD'];
+
+async function test() {
+  console.log('--- Testing /api/market-data filter logic for all symbols ---');
+  for (const symbol of SYMBOLS) {
+    try {
+      const rawCandles = await fetchCandles(symbol, '15m');
+      console.log(`[${symbol}] Loaded ${rawCandles.length} raw candles.`);
+      
+      // Let's run it through the filterForexOutlierWicks function
+      const filtered = filterForexOutlierWicks(rawCandles, symbol);
+      console.log(`[${symbol}] Filtered successfully. Count: ${filtered.length}`);
+    } catch (err) {
+      console.error(`[${symbol}] FAILED with error:`, err);
+    }
+  }
+}
+
+test();

scratch/testTelegram.js

@@ -0,0 +1,49 @@
+// scratch/testTelegram.js
+import dotenv from 'dotenv';
+dotenv.config();
+
+const token = process.env.TELEGRAM_BOT_TOKEN;
+const chatId = process.env.TELEGRAM_CHAT_ID;
+
+console.log('=== Telegram Bot Diagnostics ===');
+console.log('Loaded bot token:', token ? `${token.substring(0, 10)}... (configured)` : 'MISSING');
+console.log('Loaded chat ID:', chatId ? `${chatId}... (configured)` : 'MISSING');
+
+if (!token || !chatId) {
+  console.error('\nCRITICAL: TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID must be set in environment variables or your HF secrets.');
+  process.exit(1);
+}
+
+async function sendTestMessage() {
+  const url = `https://api.telegram.org/bot${token}/sendMessage`;
+  const msg = `🔔 <b>Trade Analyzer Connection Test</b>\n` +
+              `Status: 🟢 Connected successfully!\n` +
+              `Time: <code>${new Date().toLocaleString()}</code>\n` +
+              `This confirms your Telegram configuration is working.`;
+
+  console.log('\nSending test message to Telegram...');
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        chat_id: chatId,
+        text: msg,
+        parse_mode: 'HTML',
+      }),
+    });
+
+    const data = await res.json();
+    if (res.ok && data.ok) {
+      console.log('✅ Success! Message sent. Check your Telegram chat/channel.');
+    } else {
+      console.error('❌ Telegram API Error:', data.description || 'Unknown error');
+    }
+  } catch (err) {
+    console.error('❌ Network/Connection Error:', err.message);
+  }
+}
+
+sendTestMessage();

scratch/testUSDCAD.js

@@ -0,0 +1,42 @@
+import WebSocket from 'ws';
+globalThis.WebSocket = WebSocket;
+
+// Polyfill fetch exactly like server.js
+const originalFetch = globalThis.fetch;
+globalThis.fetch = async (input, init) => {
+  let url = typeof input === 'string' ? input : input.url;
+
+  if (url.startsWith('/api/swissquote')) {
+    url = 'https://forex-data-feed.swissquote.com/public-quotes/bboquotes/instrument/XAU/USD';
+  } else if (url.startsWith('/api/yahoo')) {
+    url = 'https://query1.finance.yahoo.com' + url.replace(/^\/api\/yahoo/, '');
+    init = init || {};
+    init.headers = {
+      ...init.headers,
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      'Origin': 'https://finance.yahoo.com',
+      'Referer': 'https://finance.yahoo.com',
+    };
+  }
+
+  return originalFetch(url, init);
+};
+
+// Import our API
+import { fetchCandles } from '../src/data/yahooFinanceAPI.js';
+
+async function test() {
+  console.log('--- Printing Last 10 USDCAD Candles ---');
+  try {
+    const candles = await fetchCandles('USDCAD', '15m');
+    console.log(`Fetched ${candles.length} candles.`);
+    const last10 = candles.slice(-10);
+    last10.forEach((c, idx) => {
+      console.log(`[${idx}] Time: ${new Date(c.time * 1000).toLocaleString()}, Open: ${c.open.toFixed(5)}, High: ${c.high.toFixed(5)}, Low: ${c.low.toFixed(5)}, Close: ${c.close.toFixed(5)}, Volume: ${c.volume}`);
+    });
+  } catch (err) {
+    console.error('Test failed:', err);
+  }
+}
+
+test();

server.js

@@ -66,12 +66,10 @@ app.use(express.json());
 
 const PORT = process.env.PORT || 7860;
 const TIMEFRAME = process.env.AUTOPILOT_TIMEFRAME || '15m';
-const SYMBOLS = ['BTCUSDT', 'ETHUSDT', 'XAUUSD', 'GBPUSD', 'EURUSD', 'USDCAD'];
+const SYMBOLS = ['BTCUSDT', 'XAUUSD', 'GBPUSD', 'USDCAD'];
 
-// Filter active autopilot symbols based on timeframe to maximize returns and eliminate noise
-const AUTOPILOT_SYMBOLS = TIMEFRAME === '1H'
-  ? ['BTCUSDT', 'XAUUSD', 'GBPUSD', 'EURUSD', 'USDCAD']
-  : ['BTCUSDT', 'XAUUSD', 'GBPUSD', 'USDCAD'];
+// Filter active autopilot symbols to maximize returns and eliminate noise
+const AUTOPILOT_SYMBOLS = ['BTCUSDT', 'XAUUSD', 'GBPUSD', 'USDCAD'];
 
 // Per-symbol Twelve Data API keys (OANDA-grade forex/metals that match TradingView).
 // Read from environment so keys stay server-side and out of the public repo/bundle.
@@ -80,7 +78,6 @@ const TWELVEDATA_KEYS = {
   XAUUSD: process.env.TWELVEDATA_KEY_XAUUSD,
   GBPUSD: process.env.TWELVEDATA_KEY_GBPUSD,
   USDCAD: process.env.TWELVEDATA_KEY_USDCAD,
-  EURUSD: process.env.TWELVEDATA_KEY_EURUSD,
 };
 const getTdKey = (symbol) => TWELVEDATA_KEYS[symbol] || null;
 

src/analysis/exitManager.js

@@ -13,9 +13,7 @@ import { rsi, ema, macd } from './indicators.js';
  */
 const CONTRACT_SPECS = {
   BTCUSDT:  { type: 'crypto',      pipValue: 1,    pipSize: 1 },
-  ETHUSDT:  { type: 'crypto',      pipValue: 1,    pipSize: 1 },
   XAUUSD:   { type: 'commodity',   pipValue: 100,  pipSize: 1 },
-  EURUSD:   { type: 'forex',       pipValue: 10,   pipSize: 0.0001 },
   GBPUSD:   { type: 'forex',       pipValue: 10,   pipSize: 0.0001 },
   USDCAD:   { type: 'forex_quote', pipValue: null,  pipSize: 0.0001 },
 };
@@ -54,9 +52,7 @@ const CONTRACT_SPECS = {
 function getSpread(symbol) {
   switch (symbol) {
     case 'BTCUSDT': return 25.0;
-    case 'ETHUSDT': return 5.0;
     case 'XAUUSD': return 0.7;
-    case 'EURUSD':
     case 'GBPUSD':
     case 'USDCAD':
       return 0.00007; // 0.7 pips
@@ -93,7 +89,7 @@ export function analyzeExit(candles, trade) {
   
   // Guard against micro-stop division anomalies in older trades
   let minThreshold = 0.00005; // half a pip for Forex
-  if (trade.symbol === 'BTCUSDT' || trade.symbol === 'ETHUSDT') {
+  if (trade.symbol === 'BTCUSDT') {
     minThreshold = 0.1; // 10 cents for crypto
   } else if (trade.symbol === 'XAUUSD') {
     minThreshold = 0.05; // 5 cents for gold

src/analysis/signalGenerator.js

@@ -17,9 +17,7 @@ import { rsi, ema, atr, macd } from './indicators.js';
 /** @type {Record<string, { type: string, pipValue: number|null, pipSize: number, label: string }>} */
 export const CONTRACT_SPECS = {
   BTCUSDT:  { type: 'crypto',      pipValue: 1,    pipSize: 1,      label: '$/coin' },
-  ETHUSDT:  { type: 'crypto',      pipValue: 1,    pipSize: 1,      label: '$/coin' },
   XAUUSD:   { type: 'commodity',   pipValue: 100,  pipSize: 1,      label: '$/point' },
-  EURUSD:   { type: 'forex',       pipValue: 10,   pipSize: 0.0001, label: '$/pip' },
   GBPUSD:   { type: 'forex',       pipValue: 10,   pipSize: 0.0001, label: '$/pip' },
   USDCAD:   { type: 'forex_quote', pipValue: null,  pipSize: 0.0001, label: '$/pip (dynamic)' },
 };
@@ -33,9 +31,7 @@ export const MAX_DAILY_LOSSES = 3;
 /** ATR multipliers config for Stop Loss buffers. */
 export const ATR_MULTIPLIERS = {
   BTCUSDT: 1.5,
-  ETHUSDT: 1.5,
   XAUUSD: 0.5,
-  EURUSD: 0.5,
   GBPUSD: 0.5,
   USDCAD: 0.5,
 };
@@ -53,9 +49,7 @@ export const ATR_CONFIG = {
 function getSpread(symbol) {
   switch (symbol) {
     case 'BTCUSDT': return 25.0;
-    case 'ETHUSDT': return 5.0;
     case 'XAUUSD': return 0.7;
-    case 'EURUSD':
     case 'GBPUSD':
     case 'USDCAD':
       return 0.00007; // 0.7 pips
@@ -137,8 +131,6 @@ export function calculateLotSize(symbol, entryPrice, slPrice, currentRate = null
     maxLots = 0.14;
   } else if (symbol === 'XAUUSD') {
     maxLots = 0.3;
-  } else if (symbol === 'ETHUSDT') {
-    maxLots = 3.0;
   } else if (spec.type === 'forex' || spec.type === 'forex_quote') {
     maxLots = 3.0;
   }
@@ -205,7 +197,7 @@ export function generateSignals(candles, symbol, dailyLossCount = 0) {
   const lastCandle = candles[candles.length - 1];
 
   // Option B: Session-based Kill Zones for Forex and Gold
-  const isCrypto = symbol === 'BTCUSDT' || symbol === 'ETHUSDT';
+  const isCrypto = symbol === 'BTCUSDT';
   if (!isCrypto) {
     const lastCandleDate = new Date(lastCandle.time * 1000);
     const utcHour = lastCandleDate.getUTCHours();
@@ -379,10 +371,8 @@ function getAtrMultiplier(symbol, timeframe) {
   if (isHigherTimeframe) {
     switch (symbol) {
       case 'BTCUSDT': return 2.5;
-      case 'ETHUSDT': return 1.5;
       case 'XAUUSD': return 0.5;
       case 'GBPUSD': return 2.0;
-      case 'EURUSD': return 1.0;
       case 'USDCAD': return 2.5;
       default: return 0.5;
     }
@@ -390,10 +380,8 @@ function getAtrMultiplier(symbol, timeframe) {
     // 15m, 5m, 1m
     switch (symbol) {
       case 'BTCUSDT': return 1.5;
-      case 'ETHUSDT': return 1.5;
       case 'XAUUSD': return 1.5;
       case 'GBPUSD': return 2.0;
-      case 'EURUSD': return 0.5;
       case 'USDCAD': return 1.0;
       default: return 0.5;
     }

src/chart/chartManager.js

@@ -137,7 +137,7 @@ export class ChartManager {
     this.lastClose = candles[candles.length - 1].close;
 
     // Configure exact precision based on asset class
-    const isForex = ['EURUSD', 'GBPUSD', 'USDCAD'].includes(symbol);
+    const isForex = ['GBPUSD', 'USDCAD'].includes(symbol);
     const precision = isForex ? 5 : 2;
     const minMove = isForex ? 0.00001 : 0.01;
 
@@ -260,7 +260,7 @@ export class ChartManager {
     if (!orderBlocks || orderBlocks.length === 0 || !candles || candles.length === 0) return;
 
     const lastClose = candles[candles.length - 1].close;
-    const isCrypto = this.symbol === 'BTCUSDT' || this.symbol === 'ETHUSDT';
+    const isCrypto = this.symbol === 'BTCUSDT';
     const limitPct = isCrypto ? 0.12 : 0.03; // 12% for crypto, 3% for forex/gold
     const maxDiff = lastClose * limitPct;
 
@@ -308,7 +308,7 @@ export class ChartManager {
     if (!zones || zones.length === 0) return;
 
     const lastClose = this.lastClose || zones[0].top;
-    const isCrypto = this.symbol === 'BTCUSDT' || this.symbol === 'ETHUSDT';
+    const isCrypto = this.symbol === 'BTCUSDT';
     const limitPct = isCrypto ? 0.12 : 0.03;
     const maxDiff = lastClose * limitPct;
 

src/components/analysisPanel.js

@@ -512,7 +512,6 @@ export class AnalysisPanel {
 
     switch (symbol) {
       case 'BTCUSDT':
-      case 'ETHUSDT':
         lots = 50 / slDist;
         risk = slDist * lots;
         distLabel = `$${slDist.toFixed(2)}`;
@@ -522,7 +521,6 @@ export class AnalysisPanel {
         risk = slDist * lots * 100;
         distLabel = `${slDist.toFixed(2)} pts`;
         break;
-      case 'EURUSD':
       case 'GBPUSD':
         const pips = slDist / 0.0001;
         lots = 50 / (pips * 10);
@@ -549,9 +547,7 @@ export class AnalysisPanel {
       maxLots = 0.14;
     } else if (symbol === 'XAUUSD') {
       maxLots = 0.3;
-    } else if (symbol === 'ETHUSDT') {
-      maxLots = 3.0;
-    } else if (['EURUSD', 'GBPUSD', 'USDCAD'].includes(symbol)) {
+    } else if (['GBPUSD', 'USDCAD'].includes(symbol)) {
       maxLots = 3.0;
     }
 
@@ -560,13 +556,11 @@ export class AnalysisPanel {
     // Recalculate precise actual risk based on final clamped lot size
     switch (symbol) {
       case 'BTCUSDT':
-      case 'ETHUSDT':
         risk = slDist * lots;
         break;
       case 'XAUUSD':
         risk = slDist * lots * 100;
         break;
-      case 'EURUSD':
       case 'GBPUSD':
         risk = (slDist / 0.0001) * lots * 10;
         break;
@@ -614,7 +608,7 @@ export class AnalysisPanel {
   _getDecimals(symbol) {
     const sym = symbol || this.currentSymbol;
     if (sym === 'XAUUSD') return 2;
-    if (sym === 'BTCUSDT' || sym === 'ETHUSDT') return 2;
+    if (sym === 'BTCUSDT') return 2;
     return 5;
   }
 

src/components/header.js

@@ -139,7 +139,6 @@ export class Header {
   _getDecimals(symbol) {
     if (symbol === 'XAUUSD') return 2;
     if (symbol === 'BTCUSDT') return 2;
-    if (symbol === 'ETHUSDT') return 2;
     return 5; // forex pairs
   }
 

src/components/tradeManager.js

@@ -617,7 +617,7 @@ export class TradeManager {
 
   getSymbolStats() {
     const stats = {};
-    const symbols = ['BTCUSDT', 'ETHUSDT', 'XAUUSD', 'GBPUSD', 'EURUSD', 'USDCAD'];
+    const symbols = ['BTCUSDT', 'XAUUSD', 'GBPUSD', 'USDCAD'];
     for (const sym of symbols) {
       stats[sym] = {
         total: 0,

src/data/dataManager.js

@@ -23,10 +23,8 @@ import { ServerStream }               from './serverStream.js';
  */
 export const SYMBOL_CONFIG = {
   BTCUSDT: { provider: 'yahoo',   wsSymbol: 'BTC-USD',        displayName: 'BTC/USDT', type: 'crypto'    },
-  ETHUSDT: { provider: 'yahoo',   wsSymbol: 'ETH-USD',        displayName: 'ETH/USDT', type: 'crypto'    },
   XAUUSD:  { provider: 'yahoo',   wsSymbol: 'GC=F',           displayName: 'XAU/USD',  type: 'commodity' },
   GBPUSD:  { provider: 'yahoo',   wsSymbol: 'GBPUSD=X',       displayName: 'GBP/USD',  type: 'forex'     },
-  EURUSD:  { provider: 'yahoo',   wsSymbol: 'EURUSD=X',       displayName: 'EUR/USD',  type: 'forex'     },
   USDCAD:  { provider: 'yahoo',   wsSymbol: 'USDCAD=X',       displayName: 'USD/CAD',  type: 'forex'     },
 };
 

src/data/twelveDataAPI.js

@@ -12,11 +12,9 @@
 // App symbol -> Twelve Data symbol (forex/metals use slash notation).
 const TD_SYMBOL = {
   XAUUSD: 'XAU/USD',
-  EURUSD: 'EUR/USD',
   GBPUSD: 'GBP/USD',
   USDCAD: 'USD/CAD',
   BTCUSDT: 'BTC/USD',
-  ETHUSDT: 'ETH/USD',
 };
 
 // App timeframe -> Twelve Data interval.

src/data/yahooFinanceAPI.js

@@ -8,10 +8,8 @@ const YAHOO_BASE = '/api/yahoo/v8/finance/chart';
 
 export const YAHOO_SYMBOL_MAP = {
   BTCUSDT: 'BTC-USD', // Bitcoin Spot
-  ETHUSDT: 'ETH-USD', // Ethereum Spot
   XAUUSD: 'GC=F',     // Gold Futures
   GBPUSD: 'GBPUSD=X', // Spot GBP/USD
-  EURUSD: 'EURUSD=X', // Spot EUR/USD
   USDCAD: 'USDCAD=X', // Spot USD/CAD
 };
 
@@ -85,7 +83,7 @@ const TIMEFRAME_CONFIG = {
  * @returns {Array} filtered candles (forex only; other symbols returned unchanged)
  */
 export function filterForexOutlierWicks(candles, symbol) {
-  if (!['EURUSD', 'GBPUSD', 'USDCAD'].includes(symbol) || !candles || candles.length === 0) {
+  if (!['GBPUSD', 'USDCAD'].includes(symbol) || !candles || candles.length === 0) {
     return candles;
   }
 

src/main.js

@@ -29,9 +29,7 @@ let history = [];
 let lastTickPrice = null;
 const livePrices = {
   BTCUSDT: 0,
-  ETHUSDT: 0,
   XAUUSD: 0,
-  EURUSD: 0,
   GBPUSD: 0,
   USDCAD: 1.38, // approximate fallback
 };