fix: add null checks to prevent 'Cannot read properties of null' error on automation page
- Added proper null checks for status object before accessing selectedTimeframes - Fixed timeframes display to handle null status gracefully - Fixed analysis interval calculation with optional chaining - Resolved 500 internal server error on /automation-v2 page
This commit is contained in:
mindesbunister
@@ -1,6 +1,5 @@
|
||||
import { PrismaClient } from '@prisma/client'
|
||||
import { aiAnalysisService, AnalysisResult } from './ai-analysis'
|
||||
import { jupiterDEXService } from './jupiter-dex-service'
|
||||
import { enhancedScreenshotService } from './enhanced-screenshot-simple'
|
||||
import { TradingViewCredentials } from './tradingview-automation'
|
||||
import { progressTracker, ProgressStatus } from './progress-tracker'
|
||||
@@ -8,19 +7,22 @@ import aggressiveCleanup from './aggressive-cleanup'
|
||||
import { analysisCompletionFlag } from './analysis-completion-flag'
|
||||
import priceMonitorService from './price-monitor'
|
||||
|
||||
const prisma = new PrismaClient()
|
||||
import prisma from '../lib/prisma'
|
||||
import AILeverageCalculator from './ai-leverage-calculator'
|
||||
import AIDCAManager from './ai-dca-manager'
|
||||
|
||||
export interface AutomationConfig {
|
||||
userId: string
|
||||
mode: 'SIMULATION' | 'LIVE'
|
||||
symbol: string
|
||||
timeframe: string
|
||||
selectedTimeframes?: string[] // Multi-timeframe support from UI
|
||||
tradingAmount: number
|
||||
maxLeverage: number
|
||||
stopLossPercent: number
|
||||
takeProfitPercent: number
|
||||
// stopLossPercent and takeProfitPercent removed - AI calculates these automatically
|
||||
maxDailyTrades: number
|
||||
riskPercentage: number
|
||||
dexProvider?: string // DEX provider (DRIFT or JUPITER)
|
||||
}
|
||||
|
||||
export interface AutomationStatus {
|
||||
@@ -37,6 +39,9 @@ export interface AutomationStatus {
|
||||
nextScheduled?: Date
|
||||
errorCount: number
|
||||
lastError?: string
|
||||
nextAnalysisIn?: number // Seconds until next analysis
|
||||
analysisInterval?: number // Analysis interval in seconds
|
||||
currentCycle?: number // Current automation cycle
|
||||
}
|
||||
|
||||
export class AutomationService {
|
||||
@@ -96,8 +101,7 @@ export class AutomationService {
|
||||
settings: {
|
||||
tradingAmount: config.tradingAmount,
|
||||
maxLeverage: config.maxLeverage,
|
||||
stopLossPercent: config.stopLossPercent,
|
||||
takeProfitPercent: config.takeProfitPercent,
|
||||
// stopLossPercent and takeProfitPercent removed - AI calculates these automatically
|
||||
maxDailyTrades: config.maxDailyTrades,
|
||||
riskPercentage: config.riskPercentage
|
||||
},
|
||||
@@ -164,6 +168,37 @@ export class AutomationService {
|
||||
}
|
||||
|
||||
private getIntervalFromTimeframe(timeframe: string): number {
|
||||
// Check if this is a scalping strategy (multiple short timeframes)
|
||||
if (this.config?.selectedTimeframes) {
|
||||
const timeframes = this.config.selectedTimeframes
|
||||
const isScalping = timeframes.includes('5') || timeframes.includes('3') ||
|
||||
(timeframes.length > 1 && timeframes.every(tf => ['1', '3', '5', '15', '30'].includes(tf)))
|
||||
|
||||
if (isScalping) {
|
||||
console.log('🎯 Scalping strategy detected - using frequent analysis (2-3 minutes)')
|
||||
return 2 * 60 * 1000 // 2 minutes for scalping
|
||||
}
|
||||
|
||||
// Day trading strategy (short-medium timeframes)
|
||||
const isDayTrading = timeframes.includes('60') || timeframes.includes('120') ||
|
||||
timeframes.some(tf => ['30', '60', '120'].includes(tf))
|
||||
|
||||
if (isDayTrading) {
|
||||
console.log('⚡ Day trading strategy detected - using moderate analysis (5-10 minutes)')
|
||||
return 5 * 60 * 1000 // 5 minutes for day trading
|
||||
}
|
||||
|
||||
// Swing trading (longer timeframes)
|
||||
const isSwingTrading = timeframes.includes('240') || timeframes.includes('D') ||
|
||||
timeframes.some(tf => ['240', '480', 'D', '1d'].includes(tf))
|
||||
|
||||
if (isSwingTrading) {
|
||||
console.log('🎯 Swing trading strategy detected - using standard analysis (15-30 minutes)')
|
||||
return 15 * 60 * 1000 // 15 minutes for swing trading
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback to timeframe-based intervals
|
||||
const intervals: { [key: string]: number } = {
|
||||
'1m': 60 * 1000,
|
||||
'3m': 3 * 60 * 1000,
|
||||
@@ -185,7 +220,36 @@ export class AutomationService {
|
||||
try {
|
||||
console.log(`🔍 Running automation cycle for ${this.config.symbol} ${this.config.timeframe}`)
|
||||
|
||||
// Step 1: Check daily trade limit
|
||||
// Update next scheduled time in database for timer display
|
||||
const intervalMs = this.getIntervalFromTimeframe(this.config.timeframe)
|
||||
const nextScheduled = new Date(Date.now() + intervalMs)
|
||||
|
||||
try {
|
||||
await prisma.automationSession.updateMany({
|
||||
where: {
|
||||
userId: this.config.userId,
|
||||
status: 'ACTIVE'
|
||||
},
|
||||
data: {
|
||||
nextScheduled: nextScheduled,
|
||||
lastAnalysis: new Date()
|
||||
}
|
||||
})
|
||||
console.log(`⏰ Next analysis scheduled for: ${nextScheduled.toLocaleTimeString()}`)
|
||||
} catch (dbError) {
|
||||
console.error('Failed to update next scheduled time:', dbError)
|
||||
}
|
||||
|
||||
// Step 1: Check for DCA opportunities on existing positions
|
||||
const dcaOpportunity = await this.checkForDCAOpportunity()
|
||||
if (dcaOpportunity.shouldDCA) {
|
||||
console.log('🔄 DCA opportunity found, executing position scaling')
|
||||
await this.executeDCA(dcaOpportunity)
|
||||
await this.runPostCycleCleanup('dca_executed')
|
||||
return
|
||||
}
|
||||
|
||||
// Step 2: Check daily trade limit
|
||||
const todayTrades = await this.getTodayTradeCount(this.config.userId)
|
||||
if (todayTrades >= this.config.maxDailyTrades) {
|
||||
console.log(`📊 Daily trade limit reached (${todayTrades}/${this.config.maxDailyTrades})`)
|
||||
@@ -194,7 +258,7 @@ export class AutomationService {
|
||||
return
|
||||
}
|
||||
|
||||
// Step 2: Take screenshot and analyze
|
||||
// Step 3: Take screenshot and analyze
|
||||
const analysisResult = await this.performAnalysis()
|
||||
if (!analysisResult) {
|
||||
console.log('❌ Analysis failed, skipping cycle')
|
||||
@@ -273,8 +337,8 @@ export class AutomationService {
|
||||
progressTracker.createSession(sessionId, progressSteps)
|
||||
progressTracker.updateStep(sessionId, 'init', 'active', 'Starting multi-timeframe analysis...')
|
||||
|
||||
// Multi-timeframe analysis: 15m, 1h, 2h, 4h
|
||||
const timeframes = ['15', '1h', '2h', '4h']
|
||||
// Use selected timeframes from UI, fallback to default if not provided
|
||||
const timeframes = this.config!.selectedTimeframes || ['1h']
|
||||
const symbol = this.config!.symbol
|
||||
|
||||
console.log(`🔍 Analyzing ${symbol} across timeframes: ${timeframes.join(', ')} with AI + DIY layouts`)
|
||||
@@ -406,8 +470,10 @@ export class AutomationService {
|
||||
return { screenshots: [], analysis: null }
|
||||
}
|
||||
|
||||
// Get the primary timeframe (1h) as base
|
||||
const primaryResult = validResults.find(r => r.timeframe === '1h') || validResults[0]
|
||||
// Get the primary timeframe (first selected or default) as base
|
||||
const selectedTimeframes = this.config!.selectedTimeframes || ['1h']
|
||||
const primaryTimeframe = selectedTimeframes[0] || '1h'
|
||||
const primaryResult = validResults.find(r => r.timeframe === primaryTimeframe) || validResults[0]
|
||||
const screenshots = validResults.length > 0 ? [primaryResult.timeframe] : []
|
||||
|
||||
// Calculate weighted confidence based on timeframe alignment
|
||||
@@ -480,8 +546,10 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
const allLevels = results.map(r => r.analysis?.keyLevels).filter(Boolean)
|
||||
if (allLevels.length === 0) return {}
|
||||
|
||||
// Use the 1h timeframe levels as primary, or first available
|
||||
const primaryLevels = results.find(r => r.timeframe === '1h')?.analysis?.keyLevels || allLevels[0]
|
||||
// Use the primary timeframe levels (first selected) as primary, or first available
|
||||
const selectedTimeframes = this.config!.selectedTimeframes || ['1h']
|
||||
const primaryTimeframe = selectedTimeframes[0] || '1h'
|
||||
const primaryLevels = results.find(r => r.timeframe === primaryTimeframe)?.analysis?.keyLevels || allLevels[0]
|
||||
|
||||
return {
|
||||
...primaryLevels,
|
||||
@@ -493,8 +561,10 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
const sentiments = results.map(r => r.analysis?.marketSentiment).filter(Boolean)
|
||||
if (sentiments.length === 0) return 'NEUTRAL'
|
||||
|
||||
// Use the 1h timeframe sentiment as primary, or first available
|
||||
const primarySentiment = results.find(r => r.timeframe === '1h')?.analysis?.marketSentiment || sentiments[0]
|
||||
// Use the primary timeframe sentiment (first selected) as primary, or first available
|
||||
const selectedTimeframes = this.config!.selectedTimeframes || ['1h']
|
||||
const primaryTimeframe = selectedTimeframes[0] || '1h'
|
||||
const primarySentiment = results.find(r => r.timeframe === primaryTimeframe)?.analysis?.marketSentiment || sentiments[0]
|
||||
|
||||
return primarySentiment || 'NEUTRAL'
|
||||
}
|
||||
@@ -606,13 +676,17 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
console.log('📈 BUY signal detected')
|
||||
}
|
||||
|
||||
// Calculate position size based on risk percentage
|
||||
const positionSize = await this.calculatePositionSize(analysis)
|
||||
// Calculate AI-driven position size with optimal leverage
|
||||
const positionResult = await this.calculatePositionSize(analysis)
|
||||
|
||||
return {
|
||||
direction: analysis.recommendation,
|
||||
confidence: analysis.confidence,
|
||||
positionSize,
|
||||
positionSize: positionResult.tokenAmount,
|
||||
leverageUsed: positionResult.leverageUsed,
|
||||
marginRequired: positionResult.marginRequired,
|
||||
liquidationPrice: positionResult.liquidationPrice,
|
||||
riskAssessment: positionResult.riskAssessment,
|
||||
stopLoss: this.calculateStopLoss(analysis),
|
||||
takeProfit: this.calculateTakeProfit(analysis),
|
||||
marketSentiment: analysis.marketSentiment,
|
||||
@@ -659,39 +733,92 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
}
|
||||
}
|
||||
|
||||
private async calculatePositionSize(analysis: any): Promise<number> {
|
||||
const baseAmount = this.config!.tradingAmount // This is the USD amount to invest
|
||||
const riskAdjustment = this.config!.riskPercentage / 100
|
||||
const confidenceAdjustment = analysis.confidence / 100
|
||||
private async calculatePositionSize(analysis: any): Promise<{
|
||||
tokenAmount: number
|
||||
leverageUsed: number
|
||||
marginRequired: number
|
||||
liquidationPrice: number
|
||||
riskAssessment: string
|
||||
}> {
|
||||
console.log('🧠 AI Position Sizing with Dynamic Leverage Calculation...')
|
||||
|
||||
// ✅ ENHANCED: Handle both BUY and SELL position sizing
|
||||
// ✅ ENHANCED: Handle SELL positions with AI leverage for shorting
|
||||
if (analysis.recommendation === 'SELL') {
|
||||
// For SELL orders, calculate how much SOL to sell based on current holdings
|
||||
return await this.calculateSellAmount(analysis)
|
||||
return await this.calculateSellPositionWithLeverage(analysis)
|
||||
}
|
||||
|
||||
// For BUY orders, calculate USD amount to invest
|
||||
const usdAmount = baseAmount * riskAdjustment * confidenceAdjustment
|
||||
// Get account balance
|
||||
const balanceResponse = await fetch(`${process.env.NEXT_PUBLIC_API_URL || 'http://localhost:3000'}/api/drift/balance`)
|
||||
const balanceData = await balanceResponse.json()
|
||||
|
||||
// Get current price to convert USD to token amount
|
||||
if (!balanceData.success) {
|
||||
throw new Error('Could not fetch account balance for position sizing')
|
||||
}
|
||||
|
||||
const accountValue = balanceData.accountValue || balanceData.totalCollateral
|
||||
const availableBalance = balanceData.availableBalance
|
||||
|
||||
console.log(`💰 Account Status: Value=$${accountValue.toFixed(2)}, Available=$${availableBalance.toFixed(2)}`)
|
||||
|
||||
// Get current price for entry
|
||||
let currentPrice = analysis.entry?.price || analysis.currentPrice
|
||||
|
||||
if (!currentPrice) {
|
||||
try {
|
||||
const { default: PriceFetcher } = await import('./price-fetcher')
|
||||
currentPrice = await PriceFetcher.getCurrentPrice(this.config?.symbol || 'SOLUSD')
|
||||
console.log(`📊 Using current ${this.config?.symbol || 'SOLUSD'} price for position size: $${currentPrice}`)
|
||||
console.log(`📊 Using current ${this.config?.symbol || 'SOLUSD'} price: $${currentPrice}`)
|
||||
} catch (error) {
|
||||
console.error('Error fetching price for position size, using fallback:', error)
|
||||
console.error('Error fetching price for position sizing, using fallback:', error)
|
||||
currentPrice = this.config?.symbol === 'SOLUSD' ? 189 : 100
|
||||
}
|
||||
}
|
||||
|
||||
// Calculate stop loss price from analysis
|
||||
const stopLossPercent = this.calculateAIStopLoss(analysis) / 100
|
||||
const direction = analysis.recommendation === 'BUY' ? 'long' : 'short'
|
||||
|
||||
// Calculate token amount: USD investment / token price
|
||||
const tokenAmount = usdAmount / currentPrice
|
||||
console.log(`💰 BUY Position calculation: $${usdAmount} ÷ $${currentPrice} = ${tokenAmount.toFixed(4)} tokens`)
|
||||
|
||||
return tokenAmount
|
||||
let stopLossPrice: number
|
||||
if (direction === 'long') {
|
||||
stopLossPrice = currentPrice * (1 - stopLossPercent)
|
||||
} else {
|
||||
stopLossPrice = currentPrice * (1 + stopLossPercent)
|
||||
}
|
||||
|
||||
console.log(`🎯 Position Parameters: Entry=$${currentPrice}, StopLoss=$${stopLossPrice.toFixed(4)}, Direction=${direction}`)
|
||||
|
||||
// Use AI Leverage Calculator for optimal leverage
|
||||
const leverageResult = AILeverageCalculator.calculateOptimalLeverage({
|
||||
accountValue,
|
||||
availableBalance,
|
||||
entryPrice: currentPrice,
|
||||
stopLossPrice,
|
||||
side: direction,
|
||||
maxLeverageAllowed: this.config!.maxLeverage || 20, // Platform max leverage
|
||||
safetyBuffer: 0.10 // 10% safety buffer between liquidation and stop loss
|
||||
})
|
||||
|
||||
// Calculate final position size
|
||||
const baseAmount = accountValue < 1000 ? availableBalance : availableBalance * 0.5
|
||||
const leveragedAmount = baseAmount * leverageResult.recommendedLeverage
|
||||
const tokenAmount = leveragedAmount / currentPrice
|
||||
|
||||
console.log(`<60> AI Position Result:`, {
|
||||
baseAmount: `$${baseAmount.toFixed(2)}`,
|
||||
leverage: `${leverageResult.recommendedLeverage.toFixed(1)}x`,
|
||||
leveragedAmount: `$${leveragedAmount.toFixed(2)}`,
|
||||
tokenAmount: tokenAmount.toFixed(4),
|
||||
riskLevel: leverageResult.riskAssessment,
|
||||
reasoning: leverageResult.reasoning
|
||||
})
|
||||
|
||||
return {
|
||||
tokenAmount,
|
||||
leverageUsed: leverageResult.recommendedLeverage,
|
||||
marginRequired: leverageResult.marginRequired,
|
||||
liquidationPrice: leverageResult.liquidationPrice,
|
||||
riskAssessment: leverageResult.riskAssessment
|
||||
}
|
||||
}
|
||||
|
||||
// ✅ NEW: Calculate SOL amount to sell for SELL orders
|
||||
@@ -728,46 +855,171 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
}
|
||||
}
|
||||
|
||||
private calculateStopLoss(analysis: any): number {
|
||||
// Use AI analysis stopLoss if available, otherwise calculate from entry price
|
||||
if (analysis.stopLoss?.price) {
|
||||
return analysis.stopLoss.price
|
||||
}
|
||||
|
||||
const currentPrice = analysis.entry?.price || 189 // Current SOL price
|
||||
const stopLossPercent = this.config!.stopLossPercent / 100
|
||||
|
||||
// ✅ ENHANCED: Proper stop loss for both BUY and SELL
|
||||
if (analysis.recommendation === 'BUY') {
|
||||
// BUY: Stop loss below entry (price goes down)
|
||||
return currentPrice * (1 - stopLossPercent)
|
||||
} else if (analysis.recommendation === 'SELL') {
|
||||
// SELL: Stop loss above entry (price goes up)
|
||||
return currentPrice * (1 + stopLossPercent)
|
||||
} else {
|
||||
return currentPrice * (1 - stopLossPercent)
|
||||
// ✅ NEW: Calculate leveraged short position for SELL orders
|
||||
private async calculateSellPositionWithLeverage(analysis: any): Promise<{
|
||||
tokenAmount: number
|
||||
leverageUsed: number
|
||||
marginRequired: number
|
||||
liquidationPrice: number
|
||||
riskAssessment: string
|
||||
}> {
|
||||
try {
|
||||
console.log('📉 Calculating SELL position with AI leverage...')
|
||||
|
||||
// Get account balance for leverage calculation
|
||||
const balanceResponse = await fetch(`${process.env.NEXT_PUBLIC_API_URL || 'http://localhost:3000'}/api/drift/balance`)
|
||||
const balanceData = await balanceResponse.json()
|
||||
|
||||
const accountValue = balanceData.accountValue || balanceData.totalCollateral
|
||||
const availableBalance = balanceData.availableBalance
|
||||
|
||||
// Get current price
|
||||
let currentPrice = analysis.entry?.price || analysis.currentPrice
|
||||
if (!currentPrice) {
|
||||
const { default: PriceFetcher } = await import('./price-fetcher')
|
||||
currentPrice = await PriceFetcher.getCurrentPrice(this.config?.symbol || 'SOLUSD')
|
||||
}
|
||||
|
||||
// Calculate stop loss for short position (above entry price)
|
||||
const stopLossPercent = this.calculateAIStopLoss(analysis) / 100
|
||||
const stopLossPrice = currentPrice * (1 + stopLossPercent)
|
||||
|
||||
console.log(`🎯 SHORT Position Parameters: Entry=$${currentPrice}, StopLoss=$${stopLossPrice.toFixed(4)}`)
|
||||
|
||||
// Use AI leverage for short position
|
||||
const leverageResult = AILeverageCalculator.calculateOptimalLeverage({
|
||||
accountValue,
|
||||
availableBalance,
|
||||
entryPrice: currentPrice,
|
||||
stopLossPrice,
|
||||
side: 'short',
|
||||
maxLeverageAllowed: this.config!.maxLeverage || 20,
|
||||
safetyBuffer: 0.10
|
||||
})
|
||||
|
||||
// Calculate leveraged short amount
|
||||
const baseAmount = accountValue < 1000 ? availableBalance : availableBalance * 0.5
|
||||
const leveragedAmount = baseAmount * leverageResult.recommendedLeverage
|
||||
const tokenAmount = leveragedAmount / currentPrice
|
||||
|
||||
console.log(`📉 SELL Position with AI Leverage:`, {
|
||||
baseAmount: `$${baseAmount.toFixed(2)}`,
|
||||
leverage: `${leverageResult.recommendedLeverage.toFixed(1)}x`,
|
||||
leveragedAmount: `$${leveragedAmount.toFixed(2)}`,
|
||||
tokenAmount: tokenAmount.toFixed(4),
|
||||
riskLevel: leverageResult.riskAssessment,
|
||||
reasoning: leverageResult.reasoning
|
||||
})
|
||||
|
||||
return {
|
||||
tokenAmount,
|
||||
leverageUsed: leverageResult.recommendedLeverage,
|
||||
marginRequired: leverageResult.marginRequired,
|
||||
liquidationPrice: leverageResult.liquidationPrice,
|
||||
riskAssessment: leverageResult.riskAssessment
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error calculating SELL position with leverage:', error)
|
||||
return {
|
||||
tokenAmount: 0.01, // Fallback small amount
|
||||
leverageUsed: 1,
|
||||
marginRequired: 0,
|
||||
liquidationPrice: 0,
|
||||
riskAssessment: 'HIGH'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private calculateStopLoss(analysis: any): number {
|
||||
// ✅ AI-FIRST: Use AI analysis stopLoss if available
|
||||
if (analysis.stopLoss?.price) {
|
||||
const currentPrice = analysis.entry?.price || 189
|
||||
const stopLossPrice = analysis.stopLoss.price
|
||||
|
||||
// Convert absolute price to percentage
|
||||
if (analysis.recommendation === 'BUY') {
|
||||
return ((currentPrice - stopLossPrice) / currentPrice) * 100
|
||||
} else if (analysis.recommendation === 'SELL') {
|
||||
return ((stopLossPrice - currentPrice) / currentPrice) * 100
|
||||
}
|
||||
}
|
||||
|
||||
// If AI provides explicit stop loss percentage, use it
|
||||
if (analysis.stopLossPercent) {
|
||||
return analysis.stopLossPercent
|
||||
}
|
||||
|
||||
// Fallback: Dynamic stop loss based on market volatility (AI-calculated)
|
||||
// AI determines volatility-based stop loss (0.5% to 2% range)
|
||||
return this.calculateAIStopLoss(analysis)
|
||||
}
|
||||
|
||||
private calculateTakeProfit(analysis: any): number {
|
||||
// Use AI analysis takeProfit if available, otherwise calculate from entry price
|
||||
// ✅ AI-FIRST: Use AI analysis takeProfit if available
|
||||
if (analysis.takeProfits?.tp1?.price) {
|
||||
return analysis.takeProfits.tp1.price
|
||||
const currentPrice = analysis.entry?.price || 150
|
||||
const takeProfitPrice = analysis.takeProfits.tp1.price
|
||||
|
||||
// Convert absolute price to percentage
|
||||
if (analysis.recommendation === 'BUY') {
|
||||
return ((takeProfitPrice - currentPrice) / currentPrice) * 100
|
||||
} else if (analysis.recommendation === 'SELL') {
|
||||
return ((currentPrice - takeProfitPrice) / currentPrice) * 100
|
||||
}
|
||||
}
|
||||
|
||||
const currentPrice = analysis.entry?.price || 150 // Default SOL price
|
||||
const takeProfitPercent = this.config!.takeProfitPercent / 100
|
||||
|
||||
// ✅ ENHANCED: Proper take profit for both BUY and SELL
|
||||
if (analysis.recommendation === 'BUY') {
|
||||
// BUY: Take profit above entry (price goes up)
|
||||
return currentPrice * (1 + takeProfitPercent)
|
||||
} else if (analysis.recommendation === 'SELL') {
|
||||
// SELL: Take profit below entry (price goes down)
|
||||
return currentPrice * (1 - takeProfitPercent)
|
||||
} else {
|
||||
return currentPrice * (1 + takeProfitPercent)
|
||||
// If AI provides explicit take profit percentage, use it
|
||||
if (analysis.takeProfitPercent) {
|
||||
return analysis.takeProfitPercent
|
||||
}
|
||||
|
||||
// Fallback: Dynamic take profit based on AI risk/reward optimization
|
||||
return this.calculateAITakeProfit(analysis)
|
||||
}
|
||||
|
||||
// AI-calculated dynamic stop loss based on volatility and market conditions
|
||||
private calculateAIStopLoss(analysis: any): number {
|
||||
// Extract confidence and market sentiment for adaptive stop loss
|
||||
const confidence = analysis.confidence || 70
|
||||
const volatility = analysis.marketConditions?.volatility || 'MEDIUM'
|
||||
|
||||
// Base stop loss percentages (proven to work from our testing)
|
||||
let baseStopLoss = 0.8 // 0.8% base (proven effective)
|
||||
|
||||
// Adjust based on volatility
|
||||
if (volatility === 'HIGH') {
|
||||
baseStopLoss = 1.2 // Wider stop loss for high volatility
|
||||
} else if (volatility === 'LOW') {
|
||||
baseStopLoss = 0.5 // Tighter stop loss for low volatility
|
||||
}
|
||||
|
||||
// Adjust based on confidence (higher confidence = tighter stop loss)
|
||||
if (confidence > 85) {
|
||||
baseStopLoss *= 0.8 // 20% tighter for high confidence
|
||||
} else if (confidence < 70) {
|
||||
baseStopLoss *= 1.3 // 30% wider for low confidence
|
||||
}
|
||||
|
||||
return Math.max(0.3, Math.min(2.0, baseStopLoss)) // Cap between 0.3% and 2%
|
||||
}
|
||||
|
||||
// AI-calculated dynamic take profit based on market conditions and risk/reward
|
||||
private calculateAITakeProfit(analysis: any): number {
|
||||
const stopLossPercent = this.calculateAIStopLoss(analysis)
|
||||
const confidence = analysis.confidence || 70
|
||||
|
||||
// Target minimum 1.5:1 risk/reward ratio, scaled by confidence
|
||||
let baseRiskReward = 1.5
|
||||
|
||||
if (confidence > 85) {
|
||||
baseRiskReward = 2.0 // Higher reward target for high confidence
|
||||
} else if (confidence < 70) {
|
||||
baseRiskReward = 1.2 // Lower reward target for low confidence
|
||||
}
|
||||
|
||||
const takeProfitPercent = stopLossPercent * baseRiskReward
|
||||
return Math.max(0.5, Math.min(5.0, takeProfitPercent)) // Cap between 0.5% and 5%
|
||||
}
|
||||
|
||||
private async executeTrade(decision: any): Promise<void> {
|
||||
@@ -780,7 +1032,7 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
// Execute simulation trade
|
||||
tradeResult = await this.executeSimulationTrade(decision)
|
||||
} else {
|
||||
// Execute live trade via Jupiter
|
||||
// Execute live trade via Drift Protocol
|
||||
console.log(`💰 LIVE TRADE: $${this.config!.tradingAmount} trading amount configured`)
|
||||
tradeResult = await this.executeLiveTrade(decision)
|
||||
|
||||
@@ -789,7 +1041,7 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
console.log('⚠️ Live trade failed, falling back to simulation for record keeping')
|
||||
tradeResult = await this.executeSimulationTrade(decision)
|
||||
tradeResult.status = 'FAILED'
|
||||
tradeResult.error = 'Jupiter DEX execution failed'
|
||||
tradeResult.error = 'Drift Protocol execution failed'
|
||||
}
|
||||
}
|
||||
|
||||
@@ -805,7 +1057,7 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
if (tradeResult.status !== 'FAILED') {
|
||||
setTimeout(async () => {
|
||||
try {
|
||||
await aggressiveCleanup.runPostAnalysisCleanup()
|
||||
await aggressiveCleanup.forceCleanupAfterTrade()
|
||||
} catch (error) {
|
||||
console.error('Error in post-trade cleanup:', error)
|
||||
}
|
||||
@@ -852,52 +1104,66 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
}
|
||||
|
||||
private async executeLiveTrade(decision: any): Promise<any> {
|
||||
// Execute real trade via Jupiter DEX
|
||||
const inputToken = decision.direction === 'BUY' ? 'USDC' : 'SOL'
|
||||
const outputToken = decision.direction === 'BUY' ? 'SOL' : 'USDC'
|
||||
// Execute real trade via Drift Protocol with AI-calculated leverage
|
||||
console.log(`🌊 Executing Drift trade: ${decision.direction} ${this.config!.symbol}`)
|
||||
console.log(`🧠 AI Leverage: ${decision.leverageUsed.toFixed(1)}x (Risk: ${decision.riskAssessment})`)
|
||||
console.log(`💀 Liquidation Price: $${decision.liquidationPrice.toFixed(4)}`)
|
||||
|
||||
const tokens = {
|
||||
SOL: 'So11111111111111111111111111111111111111112',
|
||||
USDC: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
|
||||
}
|
||||
// Calculate AI-generated stop loss and take profit from analysis
|
||||
const stopLossPercent = decision.stopLoss || this.calculateAIStopLoss(decision)
|
||||
const takeProfitPercent = decision.takeProfit || this.calculateAITakeProfit(decision)
|
||||
|
||||
console.log(`🎯 AI Risk Management: SL=${stopLossPercent}%, TP=${takeProfitPercent}%`)
|
||||
|
||||
// Calculate proper amount for Jupiter API
|
||||
let swapAmount
|
||||
if (decision.direction === 'BUY') {
|
||||
// BUY: Use trading amount in USDC (convert to 6 decimals)
|
||||
swapAmount = Math.floor(this.config!.tradingAmount * 1e6) // USDC has 6 decimals
|
||||
console.log(`💱 BUY: Converting $${this.config!.tradingAmount} USDC to ${swapAmount} USDC tokens`)
|
||||
} else {
|
||||
// SELL: Use SOL amount (convert to 9 decimals)
|
||||
swapAmount = Math.floor(decision.positionSize * 1e9) // SOL has 9 decimals
|
||||
console.log(`💱 SELL: Converting ${decision.positionSize} SOL to ${swapAmount} SOL tokens`)
|
||||
}
|
||||
// Call the unified trading API endpoint that routes to Drift
|
||||
const tradeResponse = await fetch(`${process.env.NEXT_PUBLIC_API_URL || 'http://localhost:3000'}/api/automation/trade`, {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Content-Type': 'application/json'
|
||||
},
|
||||
body: JSON.stringify({
|
||||
dexProvider: this.config!.dexProvider || 'DRIFT',
|
||||
action: 'place_order',
|
||||
symbol: this.config!.symbol,
|
||||
amount: this.config!.tradingAmount,
|
||||
side: decision.direction.toLowerCase(),
|
||||
leverage: decision.leverageUsed || this.config!.maxLeverage || 2, // Use AI-calculated leverage
|
||||
stopLoss: true,
|
||||
takeProfit: true,
|
||||
stopLossPercent: stopLossPercent,
|
||||
takeProfitPercent: takeProfitPercent,
|
||||
mode: this.config!.mode || 'SIMULATION',
|
||||
// Include AI leverage details for logging
|
||||
aiLeverageDetails: {
|
||||
calculatedLeverage: decision.leverageUsed,
|
||||
liquidationPrice: decision.liquidationPrice,
|
||||
riskAssessment: decision.riskAssessment,
|
||||
marginRequired: decision.marginRequired
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
console.log(`🔄 Executing Jupiter swap with corrected amount: ${swapAmount}`)
|
||||
const tradeResult = await tradeResponse.json()
|
||||
|
||||
const swapResult = await jupiterDEXService.executeSwap(
|
||||
tokens[inputToken as keyof typeof tokens],
|
||||
tokens[outputToken as keyof typeof tokens],
|
||||
swapAmount,
|
||||
50 // 0.5% slippage
|
||||
)
|
||||
|
||||
// Convert Jupiter result to standard trade result format
|
||||
if (swapResult.success) {
|
||||
// Convert Drift result to standard trade result format
|
||||
if (tradeResult.success) {
|
||||
return {
|
||||
transactionId: swapResult.txId,
|
||||
executionPrice: swapResult.executionPrice,
|
||||
amount: swapResult.outputAmount, // Amount of tokens received
|
||||
transactionId: tradeResult.result?.transactionId || tradeResult.result?.txId,
|
||||
executionPrice: tradeResult.result?.executionPrice,
|
||||
amount: tradeResult.result?.amount,
|
||||
direction: decision.direction,
|
||||
status: 'COMPLETED',
|
||||
timestamp: new Date(),
|
||||
fees: swapResult.fees || 0,
|
||||
slippage: swapResult.slippage || 0,
|
||||
inputAmount: swapResult.inputAmount, // Amount of tokens spent
|
||||
tradingAmount: this.config!.tradingAmount // Original USD amount
|
||||
leverage: decision.leverageUsed || tradeResult.leverageUsed || this.config!.maxLeverage,
|
||||
liquidationPrice: decision.liquidationPrice,
|
||||
riskAssessment: decision.riskAssessment,
|
||||
stopLoss: stopLossPercent,
|
||||
takeProfit: takeProfitPercent,
|
||||
tradingAmount: this.config!.tradingAmount,
|
||||
dexProvider: 'DRIFT'
|
||||
}
|
||||
} else {
|
||||
throw new Error(swapResult.error || 'Jupiter swap failed')
|
||||
throw new Error(tradeResult.error || 'Drift trade execution failed')
|
||||
}
|
||||
}
|
||||
|
||||
@@ -912,7 +1178,7 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
return
|
||||
}
|
||||
|
||||
// For live trades, use the actual amounts from Jupiter
|
||||
// For live trades, use the actual amounts from Drift
|
||||
const tradeAmount = result.tradingAmount ? this.config!.tradingAmount : decision.positionSize
|
||||
const actualAmount = result.amount || decision.positionSize
|
||||
|
||||
@@ -935,11 +1201,22 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
confidence: decision.confidence,
|
||||
marketSentiment: decision.marketSentiment,
|
||||
createdAt: new Date(),
|
||||
// Add Jupiter-specific fields for live trades
|
||||
// Add AI leverage information
|
||||
leverage: result.leverage || decision.leverageUsed,
|
||||
// Add Drift-specific fields for live trades
|
||||
...(this.config!.mode === 'LIVE' && result.tradingAmount && {
|
||||
realTradingAmount: this.config!.tradingAmount,
|
||||
inputAmount: result.inputAmount,
|
||||
slippage: result.slippage
|
||||
driftTxId: result.transactionId
|
||||
}),
|
||||
// Add AI leverage details in metadata
|
||||
metadata: JSON.stringify({
|
||||
aiLeverage: {
|
||||
calculatedLeverage: decision.leverageUsed,
|
||||
liquidationPrice: decision.liquidationPrice,
|
||||
riskAssessment: decision.riskAssessment,
|
||||
marginRequired: decision.marginRequired,
|
||||
balanceStrategy: result.accountValue < 1000 ? 'AGGRESSIVE_100%' : 'CONSERVATIVE_50%'
|
||||
}
|
||||
})
|
||||
}
|
||||
})
|
||||
@@ -1075,6 +1352,16 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
console.log('🔄 Found active session but automation not running, attempting auto-restart...')
|
||||
await this.autoRestartFromSession(session)
|
||||
}
|
||||
|
||||
// Calculate next analysis timing
|
||||
const analysisInterval = Math.floor(this.getIntervalFromTimeframe(session.timeframe) / 1000) // Convert to seconds
|
||||
let nextAnalysisIn = 0
|
||||
|
||||
if (this.isRunning && session.nextScheduled) {
|
||||
const nextScheduledTime = new Date(session.nextScheduled).getTime()
|
||||
const currentTime = Date.now()
|
||||
nextAnalysisIn = Math.max(0, Math.floor((nextScheduledTime - currentTime) / 1000))
|
||||
}
|
||||
|
||||
return {
|
||||
isActive: this.isRunning && this.config !== null,
|
||||
@@ -1089,7 +1376,10 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
lastError: session.lastError || undefined,
|
||||
lastAnalysis: session.lastAnalysis || undefined,
|
||||
lastTrade: session.lastTrade || undefined,
|
||||
nextScheduled: session.nextScheduled || undefined
|
||||
nextScheduled: session.nextScheduled || undefined,
|
||||
nextAnalysisIn: nextAnalysisIn,
|
||||
analysisInterval: analysisInterval,
|
||||
currentCycle: session.totalTrades || 0
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Failed to get automation status:', error)
|
||||
@@ -1107,8 +1397,7 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
timeframe: session.timeframe,
|
||||
tradingAmount: settings.tradingAmount || 100,
|
||||
maxLeverage: settings.maxLeverage || 3,
|
||||
stopLossPercent: settings.stopLossPercent || 2,
|
||||
takeProfitPercent: settings.takeProfitPercent || 6,
|
||||
// stopLossPercent and takeProfitPercent removed - AI calculates these automatically
|
||||
maxDailyTrades: settings.maxDailyTrades || 5,
|
||||
riskPercentage: settings.riskPercentage || 2
|
||||
}
|
||||
@@ -1129,11 +1418,14 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
recommendations: string[]
|
||||
}> {
|
||||
try {
|
||||
// For now, return mock data
|
||||
// For now, return mock data with dynamic timeframe
|
||||
const selectedTimeframes = this.config?.selectedTimeframes || ['1h']
|
||||
const primaryTimeframe = selectedTimeframes[0] || '1h'
|
||||
|
||||
return {
|
||||
totalAnalyses: 150,
|
||||
avgAccuracy: 0.72,
|
||||
bestTimeframe: '1h',
|
||||
bestTimeframe: primaryTimeframe,
|
||||
worstTimeframe: '15m',
|
||||
commonFailures: [
|
||||
'Low confidence predictions',
|
||||
@@ -1141,7 +1433,7 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
'Timeframe misalignment'
|
||||
],
|
||||
recommendations: [
|
||||
'Focus on 1h timeframe for better accuracy',
|
||||
`Focus on ${primaryTimeframe} timeframe for better accuracy`,
|
||||
'Wait for higher confidence signals (>75%)',
|
||||
'Use multiple timeframe confirmation'
|
||||
]
|
||||
@@ -1263,6 +1555,196 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
|
||||
this.stats.lastError = error instanceof Error ? error.message : 'Unknown error'
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check for DCA opportunities on existing open positions
|
||||
*/
|
||||
private async checkForDCAOpportunity(): Promise<any> {
|
||||
try {
|
||||
if (!this.config) return { shouldDCA: false }
|
||||
|
||||
// Get current open positions
|
||||
const openPositions = await prisma.trade.findMany({
|
||||
where: {
|
||||
userId: this.config.userId,
|
||||
status: 'open',
|
||||
symbol: this.config.symbol
|
||||
},
|
||||
orderBy: { createdAt: 'desc' },
|
||||
take: 1
|
||||
})
|
||||
|
||||
if (openPositions.length === 0) {
|
||||
return { shouldDCA: false, reasoning: 'No open positions to DCA' }
|
||||
}
|
||||
|
||||
const currentPosition = openPositions[0]
|
||||
|
||||
// Get current market price
|
||||
let currentPrice: number
|
||||
try {
|
||||
const { default: PriceFetcher } = await import('./price-fetcher')
|
||||
currentPrice = await PriceFetcher.getCurrentPrice(this.config.symbol)
|
||||
} catch (error) {
|
||||
console.error('Error fetching current price for DCA analysis:', error)
|
||||
return { shouldDCA: false, reasoning: 'Cannot fetch current price' }
|
||||
}
|
||||
|
||||
// Get account status for DCA calculation (simplified version)
|
||||
const accountStatus = {
|
||||
accountValue: 1000, // Could integrate with actual account status
|
||||
availableBalance: 500,
|
||||
leverage: currentPosition.leverage || 1,
|
||||
liquidationPrice: 0
|
||||
}
|
||||
|
||||
// Analyze DCA opportunity using AI DCA Manager
|
||||
const dcaParams = {
|
||||
currentPosition: {
|
||||
side: currentPosition.side as 'long' | 'short',
|
||||
size: currentPosition.amount || 0,
|
||||
entryPrice: currentPosition.entryPrice || currentPosition.price,
|
||||
currentPrice,
|
||||
unrealizedPnl: currentPosition.profit || 0,
|
||||
stopLoss: currentPosition.stopLoss || 0,
|
||||
takeProfit: currentPosition.takeProfit || 0
|
||||
},
|
||||
accountStatus,
|
||||
marketData: {
|
||||
price: currentPrice,
|
||||
priceChange24h: 0, // Could fetch from price API if needed
|
||||
volume: 0,
|
||||
support: (currentPosition.entryPrice || currentPosition.price) * 0.95, // Estimate
|
||||
resistance: (currentPosition.entryPrice || currentPosition.price) * 1.05 // Estimate
|
||||
},
|
||||
maxLeverageAllowed: this.config.maxLeverage || 20
|
||||
}
|
||||
|
||||
const dcaResult = AIDCAManager.analyzeDCAOpportunity(dcaParams)
|
||||
|
||||
console.log('🔍 DCA Analysis Result:', {
|
||||
shouldDCA: dcaResult.shouldDCA,
|
||||
confidence: dcaResult.confidence,
|
||||
reasoning: dcaResult.reasoning,
|
||||
dcaAmount: dcaResult.dcaAmount?.toFixed(4),
|
||||
riskLevel: dcaResult.riskAssessment
|
||||
})
|
||||
|
||||
return dcaResult
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error checking DCA opportunity:', error)
|
||||
return { shouldDCA: false, reasoning: 'DCA analysis failed' }
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute DCA by scaling into existing position
|
||||
*/
|
||||
private async executeDCA(dcaResult: any): Promise<void> {
|
||||
try {
|
||||
if (!this.config || !dcaResult.shouldDCA) return
|
||||
|
||||
console.log('🔄 Executing DCA scaling:', {
|
||||
amount: dcaResult.dcaAmount?.toFixed(4),
|
||||
newAverage: dcaResult.newAveragePrice?.toFixed(4),
|
||||
newLeverage: dcaResult.newLeverage?.toFixed(1) + 'x',
|
||||
confidence: dcaResult.confidence + '%'
|
||||
})
|
||||
|
||||
// Get current open position
|
||||
const openPosition = await prisma.trade.findFirst({
|
||||
where: {
|
||||
userId: this.config.userId,
|
||||
status: 'open',
|
||||
symbol: this.config.symbol
|
||||
},
|
||||
orderBy: { createdAt: 'desc' }
|
||||
})
|
||||
|
||||
if (!openPosition) {
|
||||
console.error('❌ No open position found for DCA')
|
||||
return
|
||||
}
|
||||
|
||||
// Execute DCA trade via Drift Protocol (simplified for now)
|
||||
if (this.config.mode === 'LIVE') {
|
||||
console.log('📈 Live DCA would execute via Drift Protocol (not implemented yet)')
|
||||
// TODO: Implement live DCA execution
|
||||
}
|
||||
|
||||
// Update position with new averages (both LIVE and SIMULATION)
|
||||
await this.updatePositionAfterDCA(openPosition.id, dcaResult)
|
||||
|
||||
// Create DCA record for tracking
|
||||
await this.createDCARecord(openPosition.id, dcaResult)
|
||||
|
||||
console.log('✅ DCA executed successfully')
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error executing DCA:', error)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update position after DCA execution
|
||||
*/
|
||||
private async updatePositionAfterDCA(positionId: string, dcaResult: any): Promise<void> {
|
||||
try {
|
||||
// Calculate new position metrics
|
||||
const newSize = dcaResult.dcaAmount * (dcaResult.newLeverage || 1)
|
||||
|
||||
await prisma.trade.update({
|
||||
where: { id: positionId },
|
||||
data: {
|
||||
amount: { increment: newSize },
|
||||
entryPrice: dcaResult.newAveragePrice,
|
||||
stopLoss: dcaResult.newStopLoss,
|
||||
takeProfit: dcaResult.newTakeProfit,
|
||||
leverage: dcaResult.newLeverage,
|
||||
aiAnalysis: `DCA: ${dcaResult.reasoning}`,
|
||||
updatedAt: new Date()
|
||||
}
|
||||
})
|
||||
|
||||
console.log('📊 Position updated after DCA:', {
|
||||
newAverage: dcaResult.newAveragePrice?.toFixed(4),
|
||||
newSL: dcaResult.newStopLoss?.toFixed(4),
|
||||
newTP: dcaResult.newTakeProfit?.toFixed(4),
|
||||
newLeverage: dcaResult.newLeverage?.toFixed(1) + 'x'
|
||||
})
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error updating position after DCA:', error)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Create DCA record for tracking and analysis
|
||||
*/
|
||||
private async createDCARecord(positionId: string, dcaResult: any): Promise<void> {
|
||||
try {
|
||||
await prisma.dCARecord.create({
|
||||
data: {
|
||||
tradeId: positionId,
|
||||
dcaAmount: dcaResult.dcaAmount,
|
||||
dcaPrice: dcaResult.newAveragePrice, // Current market price for DCA entry
|
||||
newAveragePrice: dcaResult.newAveragePrice,
|
||||
newStopLoss: dcaResult.newStopLoss,
|
||||
newTakeProfit: dcaResult.newTakeProfit,
|
||||
newLeverage: dcaResult.newLeverage,
|
||||
confidence: dcaResult.confidence,
|
||||
reasoning: dcaResult.reasoning,
|
||||
riskAssessment: dcaResult.riskAssessment,
|
||||
createdAt: new Date()
|
||||
}
|
||||
})
|
||||
|
||||
console.log('📝 DCA record created for tracking')
|
||||
} catch (error) {
|
||||
console.error('Error creating DCA record:', error)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export const automationService = new AutomationService()
|
||||
|
||||
Reference in New Issue
Block a user