634738bfb4
Backtest results (28 days): - Original: 32 trades, 43.8% win rate, -16.82 loss - New: 13 trades, 69.2% win rate, +49.99 profit - Improvement: +66.81 (+991%), +25.5% hit rate Changes: 1. Set MIN_SIGNAL_QUALITY_SCORE_LONG/SHORT=95 (was 90/85) 2. Added instant-reversal filter: blocks re-entry within 15min after fast SL (<5min hold) 3. Added 5-candle time exit: exits after 25min if MFE <0 4. HTF filter already effective (no Q≥95 trades blocked) Expected outcome: Turn consistent losses into consistent profits with 69% win rate
596 lines
24 KiB
TypeScript
596 lines
24 KiB
TypeScript
/**
|
|
* Risk Check API Endpoint
|
|
*
|
|
* Called by n8n workflow before executing trade
|
|
* POST /api/trading/check-risk
|
|
*/
|
|
|
|
import { NextRequest, NextResponse } from 'next/server'
|
|
import { getMergedConfig, TradingConfig, getMinQualityScoreForDirection, normalizeTradingViewSymbol } from '@/config/trading'
|
|
import { getInitializedPositionManager, ActiveTrade } from '@/lib/trading/position-manager'
|
|
import { getLastTradeTime, getLastTradeTimeForSymbol, getTradesInLastHour, getTodayPnL, createBlockedSignal } from '@/lib/database/trades'
|
|
import { getPythPriceMonitor } from '@/lib/pyth/price-monitor'
|
|
import { scoreSignalQuality, SignalQualityResult } from '@/lib/trading/signal-quality'
|
|
import { initializeDriftService } from '@/lib/drift/client'
|
|
import { SUPPORTED_MARKETS } from '@/config/trading'
|
|
import { getSmartValidationQueue } from '@/lib/trading/smart-validation-queue'
|
|
|
|
export interface RiskCheckRequest {
|
|
symbol: string
|
|
direction: 'long' | 'short'
|
|
timeframe?: string // e.g., "5" for 5min, "60" for 1H, "D" for daily
|
|
currentPrice?: number // Current market price (for flip-flop context)
|
|
signalPrice?: number // TradingView-provided price snapshot
|
|
indicatorVersion?: string // Pine Script version tag (v8/v9/v10)
|
|
// Optional context metrics from TradingView
|
|
atr?: number
|
|
adx?: number
|
|
rsi?: number
|
|
volumeRatio?: number
|
|
pricePosition?: number
|
|
maGap?: number // V9: MA gap convergence metric
|
|
}
|
|
|
|
export interface RiskCheckResponse {
|
|
allowed: boolean
|
|
reason?: string
|
|
details?: string
|
|
qualityScore?: number
|
|
qualityReasons?: string[]
|
|
}
|
|
|
|
/**
|
|
* Get current price reliably using multiple fallback methods
|
|
* Priority: Pyth cache → Drift oracle → TradingView signal price
|
|
*/
|
|
async function getCurrentPrice(symbol: string, fallbackPrice?: number): Promise<number> {
|
|
// Try Pyth cache first (fastest)
|
|
const priceMonitor = getPythPriceMonitor()
|
|
const latestPrice = priceMonitor.getCachedPrice(symbol)
|
|
if (latestPrice?.price && latestPrice.price > 0) {
|
|
return latestPrice.price
|
|
}
|
|
|
|
// Try Drift oracle (authoritative)
|
|
try {
|
|
const driftService = await initializeDriftService()
|
|
const marketConfig = SUPPORTED_MARKETS[symbol]
|
|
if (marketConfig && driftService) {
|
|
const oraclePrice = await driftService.getOraclePrice(marketConfig.driftMarketIndex)
|
|
if (oraclePrice > 0) {
|
|
return oraclePrice
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.warn('⚠️ Failed to get Drift oracle price:', error)
|
|
}
|
|
|
|
// Fallback to TradingView signal price
|
|
if (fallbackPrice && fallbackPrice > 0) {
|
|
return fallbackPrice
|
|
}
|
|
|
|
console.error('❌ Unable to get current price from any source')
|
|
return 0
|
|
}
|
|
|
|
/**
|
|
* Position Scaling Validation
|
|
* Determines if adding to an existing position is allowed
|
|
*/
|
|
async function shouldAllowScaling(
|
|
existingTrade: ActiveTrade,
|
|
newSignal: RiskCheckRequest,
|
|
config: TradingConfig
|
|
): Promise<{ allowed: boolean; reasons: string[]; qualityScore?: number; qualityReasons?: string[] }> {
|
|
const reasons: string[] = []
|
|
|
|
// Check if we have context metrics
|
|
if (!newSignal.atr || !newSignal.adx || !newSignal.pricePosition) {
|
|
reasons.push('Missing signal metrics for scaling validation')
|
|
return { allowed: false, reasons }
|
|
}
|
|
|
|
// 1. Calculate new signal quality score
|
|
const qualityScore = await scoreSignalQuality({
|
|
atr: newSignal.atr,
|
|
adx: newSignal.adx,
|
|
rsi: newSignal.rsi || 50,
|
|
volumeRatio: newSignal.volumeRatio || 1,
|
|
pricePosition: newSignal.pricePosition,
|
|
maGap: newSignal.maGap, // V9: MA gap convergence scoring
|
|
direction: newSignal.direction,
|
|
symbol: newSignal.symbol,
|
|
currentPrice: newSignal.currentPrice,
|
|
minScore: config.minScaleQualityScore,
|
|
})
|
|
|
|
// 2. Check quality score (higher bar than initial entry)
|
|
if (qualityScore.score < config.minScaleQualityScore) {
|
|
reasons.push(`Quality score too low: ${qualityScore.score} (need ${config.minScaleQualityScore}+)`)
|
|
return { allowed: false, reasons, qualityScore: qualityScore.score, qualityReasons: qualityScore.reasons }
|
|
}
|
|
|
|
// 3. Check current position profitability
|
|
const priceMonitor = getPythPriceMonitor()
|
|
const latestPrice = priceMonitor.getCachedPrice(newSignal.symbol)
|
|
const currentPrice = latestPrice?.price
|
|
|
|
if (!currentPrice) {
|
|
reasons.push('Unable to fetch current price')
|
|
return { allowed: false, reasons, qualityScore: qualityScore.score }
|
|
}
|
|
|
|
const pnlPercent = existingTrade.direction === 'long'
|
|
? ((currentPrice - existingTrade.entryPrice) / existingTrade.entryPrice) * 100
|
|
: ((existingTrade.entryPrice - currentPrice) / existingTrade.entryPrice) * 100
|
|
|
|
if (pnlPercent < config.minProfitForScale) {
|
|
reasons.push(`Position not profitable enough: ${pnlPercent.toFixed(2)}% (need ${config.minProfitForScale}%+)`)
|
|
return { allowed: false, reasons, qualityScore: qualityScore.score }
|
|
}
|
|
|
|
// 4. Check ADX trend strengthening
|
|
const originalAdx = existingTrade.originalAdx || 0
|
|
const adxIncrease = newSignal.adx - originalAdx
|
|
|
|
if (adxIncrease < config.minAdxIncrease) {
|
|
reasons.push(`ADX not strengthening enough: +${adxIncrease.toFixed(1)} (need +${config.minAdxIncrease})`)
|
|
return { allowed: false, reasons, qualityScore: qualityScore.score }
|
|
}
|
|
|
|
// 5. Check price position (don't chase near resistance)
|
|
if (newSignal.pricePosition > config.maxPricePositionForScale) {
|
|
reasons.push(`Price too high in range: ${newSignal.pricePosition.toFixed(0)}% (max ${config.maxPricePositionForScale}%)`)
|
|
return { allowed: false, reasons, qualityScore: qualityScore.score }
|
|
}
|
|
|
|
// 6. Check max position size (if already scaled)
|
|
const totalScaled = existingTrade.timesScaled || 0
|
|
const currentMultiplier = 1 + (totalScaled * (config.scaleSizePercent / 100))
|
|
const newMultiplier = currentMultiplier + (config.scaleSizePercent / 100)
|
|
|
|
if (newMultiplier > config.maxScaleMultiplier) {
|
|
reasons.push(`Max position size reached: ${(currentMultiplier * 100).toFixed(0)}% (max ${(config.maxScaleMultiplier * 100).toFixed(0)}%)`)
|
|
return { allowed: false, reasons, qualityScore: qualityScore.score }
|
|
}
|
|
|
|
// All checks passed!
|
|
reasons.push(`Quality: ${qualityScore.score}/100`)
|
|
reasons.push(`P&L: +${pnlPercent.toFixed(2)}%`)
|
|
reasons.push(`ADX increased: +${adxIncrease.toFixed(1)}`)
|
|
reasons.push(`Price position: ${newSignal.pricePosition.toFixed(0)}%`)
|
|
|
|
return {
|
|
allowed: true,
|
|
reasons,
|
|
qualityScore: qualityScore.score,
|
|
qualityReasons: qualityScore.reasons
|
|
}
|
|
}
|
|
|
|
export async function POST(request: NextRequest): Promise<NextResponse<RiskCheckResponse>> {
|
|
try {
|
|
// Verify authorization
|
|
const authHeader = request.headers.get('authorization')
|
|
const expectedAuth = `Bearer ${process.env.API_SECRET_KEY}`
|
|
|
|
if (!authHeader || authHeader !== expectedAuth) {
|
|
return NextResponse.json(
|
|
{
|
|
allowed: false,
|
|
reason: 'Unauthorized',
|
|
},
|
|
{ status: 401 }
|
|
)
|
|
}
|
|
|
|
const body: RiskCheckRequest = await request.json()
|
|
const fallbackPrice = body.currentPrice ?? body.signalPrice
|
|
|
|
console.log('🔍 Risk check for:', body)
|
|
|
|
// 🔬 MULTI-TIMEFRAME DATA COLLECTION
|
|
// Allow all non-5min signals to bypass risk checks (they'll be saved as data collection in execute endpoint)
|
|
const timeframe = body.timeframe || '5'
|
|
if (timeframe !== '5') {
|
|
console.log(`📊 DATA COLLECTION: ${timeframe}min signal bypassing risk checks (will save in execute endpoint)`)
|
|
return NextResponse.json({
|
|
allowed: true,
|
|
reason: 'Multi-timeframe data collection',
|
|
details: `${timeframe}min signal will be saved for analysis but not executed`,
|
|
})
|
|
}
|
|
|
|
const config = getMergedConfig()
|
|
|
|
// Check for existing positions on the same symbol
|
|
const positionManager = await getInitializedPositionManager()
|
|
const existingTrades = Array.from(positionManager.getActiveTrades().values())
|
|
const existingPosition = existingTrades.find(trade => trade.symbol === body.symbol)
|
|
|
|
if (existingPosition) {
|
|
// SAME direction - check if position scaling is allowed
|
|
if (existingPosition.direction === body.direction) {
|
|
// Position scaling feature
|
|
if (config.enablePositionScaling) {
|
|
const scalingCheck = await shouldAllowScaling(existingPosition, body, config)
|
|
|
|
if (scalingCheck.allowed) {
|
|
console.log('✅ Position scaling ALLOWED:', scalingCheck.reasons)
|
|
return NextResponse.json({
|
|
allowed: true,
|
|
reason: 'Position scaling',
|
|
details: `Scaling into ${body.direction} position - ${scalingCheck.reasons.join(', ')}`,
|
|
qualityScore: scalingCheck.qualityScore,
|
|
qualityReasons: scalingCheck.qualityReasons,
|
|
})
|
|
} else {
|
|
console.log('🚫 Position scaling BLOCKED:', scalingCheck.reasons)
|
|
return NextResponse.json({
|
|
allowed: false,
|
|
reason: 'Scaling not allowed',
|
|
details: scalingCheck.reasons.join(', '),
|
|
qualityScore: scalingCheck.qualityScore,
|
|
})
|
|
}
|
|
}
|
|
|
|
// Scaling disabled - block duplicate position
|
|
console.log('🚫 Risk check BLOCKED: Duplicate position (same direction)', {
|
|
symbol: body.symbol,
|
|
existingDirection: existingPosition.direction,
|
|
requestedDirection: body.direction,
|
|
existingEntry: existingPosition.entryPrice,
|
|
})
|
|
|
|
return NextResponse.json({
|
|
allowed: false,
|
|
reason: 'Duplicate position',
|
|
details: `Already have ${existingPosition.direction} position on ${body.symbol} (entry: $${existingPosition.entryPrice}). Enable scaling in settings to add to position.`,
|
|
})
|
|
}
|
|
|
|
// OPPOSITE direction - potential signal flip
|
|
// Don't auto-allow! Let it go through normal quality checks below
|
|
console.log('🔄 Potential signal flip detected - checking quality score', {
|
|
symbol: body.symbol,
|
|
existingDirection: existingPosition.direction,
|
|
newDirection: body.direction,
|
|
note: 'Will flip IF signal quality passes',
|
|
})
|
|
|
|
// Continue to quality checks below instead of returning early
|
|
}
|
|
|
|
// Check if we have context metrics (used throughout the function)
|
|
const hasContextMetrics = body.atr !== undefined && body.atr > 0
|
|
|
|
// 1. Check daily drawdown limit
|
|
const todayPnL = await getTodayPnL()
|
|
if (todayPnL < config.maxDailyDrawdown) {
|
|
console.log('🚫 Risk check BLOCKED: Daily drawdown limit reached', {
|
|
todayPnL: todayPnL.toFixed(2),
|
|
maxDrawdown: config.maxDailyDrawdown,
|
|
})
|
|
|
|
return NextResponse.json({
|
|
allowed: false,
|
|
reason: 'Daily drawdown limit',
|
|
details: `Today's P&L ($${todayPnL.toFixed(2)}) has reached max drawdown limit ($${config.maxDailyDrawdown})`,
|
|
})
|
|
}
|
|
|
|
// 2. Check trades per hour limit
|
|
const tradesInLastHour = await getTradesInLastHour()
|
|
if (tradesInLastHour >= config.maxTradesPerHour) {
|
|
console.log('🚫 Risk check BLOCKED: Hourly trade limit reached', {
|
|
tradesInLastHour,
|
|
maxTradesPerHour: config.maxTradesPerHour,
|
|
})
|
|
|
|
// Save blocked signal if we have metrics
|
|
if (hasContextMetrics) {
|
|
const currentPrice = await getCurrentPrice(body.symbol, fallbackPrice)
|
|
|
|
if (currentPrice > 0) {
|
|
await createBlockedSignal({
|
|
symbol: body.symbol,
|
|
direction: body.direction,
|
|
timeframe: body.timeframe,
|
|
signalPrice: currentPrice,
|
|
atr: body.atr,
|
|
adx: body.adx,
|
|
rsi: body.rsi,
|
|
volumeRatio: body.volumeRatio,
|
|
pricePosition: body.pricePosition,
|
|
signalQualityScore: 0, // Not calculated yet
|
|
minScoreRequired: config.minSignalQualityScore,
|
|
blockReason: 'HOURLY_TRADE_LIMIT',
|
|
blockDetails: `${tradesInLastHour} trades in last hour (max: ${config.maxTradesPerHour})`,
|
|
indicatorVersion: body.indicatorVersion || 'v5',
|
|
})
|
|
} else {
|
|
console.warn('⚠️ Skipping blocked signal save: price unavailable (hourly limit)')
|
|
}
|
|
}
|
|
|
|
return NextResponse.json({
|
|
allowed: false,
|
|
reason: 'Hourly trade limit',
|
|
details: `Already placed ${tradesInLastHour} trades in the last hour (max: ${config.maxTradesPerHour})`,
|
|
})
|
|
}
|
|
|
|
// 3. Check cooldown period PER SYMBOL (not global)
|
|
const lastTradeTimeForSymbol = await getLastTradeTimeForSymbol(body.symbol)
|
|
if (lastTradeTimeForSymbol && config.minTimeBetweenTrades > 0) {
|
|
const timeSinceLastTrade = Date.now() - lastTradeTimeForSymbol.getTime()
|
|
const cooldownMs = config.minTimeBetweenTrades * 60 * 1000 // Convert minutes to milliseconds
|
|
|
|
if (timeSinceLastTrade < cooldownMs) {
|
|
const remainingMs = cooldownMs - timeSinceLastTrade
|
|
const remainingMinutes = Math.ceil(remainingMs / 60000)
|
|
|
|
console.log('🚫 Risk check BLOCKED: Cooldown period active for', body.symbol, {
|
|
lastTradeTime: lastTradeTimeForSymbol.toISOString(),
|
|
timeSinceLastTradeMs: timeSinceLastTrade,
|
|
cooldownMs,
|
|
remainingMinutes,
|
|
})
|
|
|
|
// Save blocked signal if we have metrics
|
|
if (hasContextMetrics) {
|
|
const currentPrice = await getCurrentPrice(body.symbol, fallbackPrice)
|
|
|
|
if (currentPrice > 0) {
|
|
await createBlockedSignal({
|
|
symbol: body.symbol,
|
|
direction: body.direction,
|
|
timeframe: body.timeframe,
|
|
signalPrice: currentPrice,
|
|
atr: body.atr,
|
|
adx: body.adx,
|
|
rsi: body.rsi,
|
|
volumeRatio: body.volumeRatio,
|
|
pricePosition: body.pricePosition,
|
|
signalQualityScore: 0, // Not calculated yet
|
|
minScoreRequired: config.minSignalQualityScore,
|
|
blockReason: 'COOLDOWN_PERIOD',
|
|
blockDetails: `Wait ${remainingMinutes} more min (cooldown: ${config.minTimeBetweenTrades} min)`,
|
|
indicatorVersion: body.indicatorVersion || 'v5',
|
|
})
|
|
} else {
|
|
console.warn('⚠️ Skipping blocked signal save: price unavailable (cooldown)')
|
|
}
|
|
}
|
|
|
|
return NextResponse.json({
|
|
allowed: false,
|
|
reason: 'Cooldown period',
|
|
details: `Must wait ${remainingMinutes} more minute(s) before next ${body.symbol} trade (cooldown: ${config.minTimeBetweenTrades} min)`,
|
|
})
|
|
}
|
|
}
|
|
|
|
// 4. Check for instant reversal (fast SL within 1 candle - Dec 17, 2025)
|
|
// Detect if most recent trade on this symbol was stopped out within 5 minutes
|
|
// This prevents re-entering immediately after being whipsawed
|
|
if (hasContextMetrics && body.timeframe === '5') {
|
|
const recentTrades = await getTradesInLastHour()
|
|
const symbolRecentTrades = recentTrades.filter(t =>
|
|
t.symbol === body.symbol &&
|
|
t.exitReason === 'SL' &&
|
|
t.holdTimeSeconds !== null &&
|
|
t.holdTimeSeconds <= 300 // 5 minutes = 1 candle
|
|
)
|
|
|
|
if (symbolRecentTrades.length > 0) {
|
|
const lastFastSL = symbolRecentTrades[0]
|
|
const timeSinceLastSL = Date.now() - new Date(lastFastSL.exitTime!).getTime()
|
|
const cooldownMs = 15 * 60 * 1000 // 15 minute cooldown after instant reversal
|
|
|
|
if (timeSinceLastSL < cooldownMs) {
|
|
const remainingMinutes = Math.ceil((cooldownMs - timeSinceLastSL) / 60000)
|
|
|
|
console.log('🚫 Risk check BLOCKED: Instant reversal detected', {
|
|
symbol: body.symbol,
|
|
lastSLTime: lastFastSL.exitTime,
|
|
holdTime: lastFastSL.holdTimeSeconds,
|
|
remainingCooldown: remainingMinutes,
|
|
})
|
|
|
|
const currentPrice = await getCurrentPrice(body.symbol, fallbackPrice)
|
|
if (currentPrice > 0) {
|
|
await createBlockedSignal({
|
|
symbol: body.symbol,
|
|
direction: body.direction,
|
|
timeframe: body.timeframe,
|
|
signalPrice: currentPrice,
|
|
atr: body.atr,
|
|
adx: body.adx,
|
|
rsi: body.rsi,
|
|
volumeRatio: body.volumeRatio,
|
|
pricePosition: body.pricePosition,
|
|
signalQualityScore: 0,
|
|
minScoreRequired: config.minSignalQualityScore,
|
|
blockReason: 'INSTANT_REVERSAL_RISK',
|
|
blockDetails: `Fast SL ${remainingMinutes}min ago (${lastFastSL.holdTimeSeconds}s hold). Wait ${remainingMinutes}min.`,
|
|
indicatorVersion: body.indicatorVersion || 'v5',
|
|
})
|
|
}
|
|
|
|
return NextResponse.json({
|
|
allowed: false,
|
|
reason: 'Instant reversal risk',
|
|
details: `Last trade stopped out in ${lastFastSL.holdTimeSeconds}s. Wait ${remainingMinutes} more minutes to avoid whipsaw.`,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// 5. Check signal quality (if context metrics provided)
|
|
if (hasContextMetrics) {
|
|
// Get current price from Pyth for flip-flop price context check
|
|
const priceMonitor = getPythPriceMonitor()
|
|
const latestPrice = priceMonitor.getCachedPrice(body.symbol)
|
|
const currentPrice = latestPrice?.price || fallbackPrice || 0
|
|
|
|
// Use direction-specific quality threshold (Nov 23, 2025)
|
|
const minQualityScore = getMinQualityScoreForDirection(body.direction, config)
|
|
|
|
const qualityScore = await scoreSignalQuality({
|
|
atr: body.atr || 0,
|
|
adx: body.adx || 0,
|
|
rsi: body.rsi || 0,
|
|
volumeRatio: body.volumeRatio || 0,
|
|
pricePosition: body.pricePosition || 0,
|
|
maGap: body.maGap, // V9: MA gap convergence scoring
|
|
direction: body.direction,
|
|
symbol: body.symbol,
|
|
currentPrice: currentPrice,
|
|
timeframe: body.timeframe, // Pass timeframe for context-aware scoring
|
|
minScore: minQualityScore // Use direction-specific threshold
|
|
})
|
|
|
|
if (!qualityScore.passed) {
|
|
console.log('🚫 Risk check BLOCKED: Signal quality too low', {
|
|
score: qualityScore.score,
|
|
direction: body.direction,
|
|
threshold: minQualityScore,
|
|
reasons: qualityScore.reasons
|
|
})
|
|
|
|
// Get current price for the blocked signal record
|
|
const currentPrice = await getCurrentPrice(body.symbol, fallbackPrice)
|
|
|
|
// CRITICAL FIX (Dec 12, 2025): Smart validation integration
|
|
// Check if signal quality is in validation range (50-89)
|
|
const isInValidationRange = qualityScore.score >= 50 && qualityScore.score < 90
|
|
|
|
// Save blocked signal to database for future analysis
|
|
if (currentPrice > 0) {
|
|
// SMART VALIDATION QUEUE (Nov 30, 2025 - FIXED Dec 12, 2025)
|
|
// Queue marginal quality signals (50-89) for validation instead of hard-blocking
|
|
const blockReason = isInValidationRange ? 'SMART_VALIDATION_QUEUED' : 'QUALITY_SCORE_TOO_LOW'
|
|
const blockDetails = isInValidationRange
|
|
? `Score: ${qualityScore.score}/${minQualityScore} - Queued for validation (will enter if +0.3%, abandon if -1.0%)`
|
|
: `Score: ${qualityScore.score}/${minQualityScore} - ${qualityScore.reasons.join(', ')}`
|
|
|
|
await createBlockedSignal({
|
|
symbol: body.symbol,
|
|
direction: body.direction,
|
|
timeframe: body.timeframe,
|
|
signalPrice: currentPrice,
|
|
atr: body.atr,
|
|
adx: body.adx,
|
|
rsi: body.rsi,
|
|
volumeRatio: body.volumeRatio,
|
|
pricePosition: body.pricePosition,
|
|
signalQualityScore: qualityScore.score,
|
|
signalQualityVersion: 'v4',
|
|
scoreBreakdown: { reasons: qualityScore.reasons },
|
|
minScoreRequired: minQualityScore,
|
|
blockReason: blockReason,
|
|
blockDetails: blockDetails,
|
|
indicatorVersion: body.indicatorVersion || 'v5',
|
|
})
|
|
|
|
// Add to validation queue if in range
|
|
if (isInValidationRange) {
|
|
const validationQueue = getSmartValidationQueue()
|
|
|
|
// CRITICAL FIX (Dec 1, 2025): Normalize TradingView symbol format to Drift format
|
|
const normalizedSymbol = normalizeTradingViewSymbol(body.symbol)
|
|
|
|
// CRITICAL FIX (Dec 15, 2025): Check if symbol trading is enabled BEFORE queueing
|
|
// Don't send Telegram notifications for data-collection-only symbols
|
|
let enabled = true
|
|
if (normalizedSymbol === 'SOL-PERP' && config.solana) {
|
|
enabled = config.solana.enabled
|
|
} else if (normalizedSymbol === 'ETH-PERP' && config.ethereum) {
|
|
enabled = config.ethereum.enabled
|
|
} else if (normalizedSymbol === 'FARTCOIN-PERP' && config.fartcoin) {
|
|
enabled = config.fartcoin.enabled
|
|
}
|
|
|
|
if (!enabled) {
|
|
console.log(`⛔ Skipping validation queue: ${normalizedSymbol} trading disabled (data collection only)`)
|
|
console.log(` Signal will be saved to database for analysis without notifications`)
|
|
} else {
|
|
const queued = await validationQueue.addSignal({
|
|
blockReason: 'SMART_VALIDATION_QUEUED',
|
|
symbol: normalizedSymbol,
|
|
direction: body.direction,
|
|
originalPrice: currentPrice,
|
|
qualityScore: qualityScore.score,
|
|
atr: body.atr,
|
|
adx: body.adx,
|
|
rsi: body.rsi,
|
|
volumeRatio: body.volumeRatio,
|
|
pricePosition: body.pricePosition,
|
|
indicatorVersion: body.indicatorVersion || 'v5',
|
|
timeframe: body.timeframe || '5',
|
|
})
|
|
|
|
if (queued) {
|
|
console.log(`🧠 Signal queued for smart validation: ${normalizedSymbol} ${body.direction} (quality ${qualityScore.score})`)
|
|
}
|
|
}
|
|
} else {
|
|
console.log(`❌ Signal quality too low for validation: ${qualityScore.score} (need 50-89 range)`)
|
|
}
|
|
} else {
|
|
console.warn('⚠️ Skipping blocked signal save: price unavailable (quality block)')
|
|
}
|
|
|
|
return NextResponse.json({
|
|
allowed: false,
|
|
reason: 'Signal quality too low',
|
|
details: `Score: ${qualityScore.score}/100 - ${qualityScore.reasons.join(', ')}`,
|
|
qualityScore: qualityScore.score,
|
|
qualityReasons: qualityScore.reasons
|
|
})
|
|
}
|
|
|
|
console.log(`✅ Risk check PASSED: All checks passed`, {
|
|
todayPnL: todayPnL.toFixed(2),
|
|
tradesLastHour: tradesInLastHour,
|
|
cooldownPassed: lastTradeTimeForSymbol ? 'yes' : `no previous ${body.symbol} trades`,
|
|
qualityScore: qualityScore.score,
|
|
qualityReasons: qualityScore.reasons
|
|
})
|
|
|
|
return NextResponse.json({
|
|
allowed: true,
|
|
details: 'All risk checks passed',
|
|
qualityScore: qualityScore.score,
|
|
qualityReasons: qualityScore.reasons
|
|
})
|
|
}
|
|
|
|
console.log(`✅ Risk check PASSED: All checks passed`, {
|
|
todayPnL: todayPnL.toFixed(2),
|
|
tradesLastHour: tradesInLastHour,
|
|
cooldownPassed: lastTradeTimeForSymbol ? 'yes' : `no previous ${body.symbol} trades`,
|
|
})
|
|
|
|
return NextResponse.json({
|
|
allowed: true,
|
|
details: 'All risk checks passed',
|
|
})
|
|
|
|
} catch (error) {
|
|
console.error('❌ Risk check error:', error)
|
|
|
|
return NextResponse.json(
|
|
{
|
|
allowed: false,
|
|
reason: 'Server error',
|
|
details: error instanceof Error ? error.message : 'Unknown error',
|
|
},
|
|
{ status: 500 }
|
|
)
|
|
}
|
|
}
|