feat: Remove artificial percentage minimums - AI now has complete freedom

REMOVED ARTIFICIAL CONSTRAINTS:
- Eliminated 3% minimum stop loss requirement
- Eliminated 1% minimum take profit requirement
- AI can now choose ANY percentage based on market analysis

- Updated app/api/drift/trade/route.js to use exact AI percentages
- Removed Math.max() constraints that forced minimums
- AI now has 0.1%+ to 50%+ percentage freedom

- Modified AI_RISK_MANAGEMENT.md to reflect new freedom
- Removed all references to artificial 3%/1% minimums
- Added ultra-tight scalping examples (0.1%-1%)
- Updated volatility guidelines for all trading styles

 PROVEN WITH REAL ORDERS:
- Transaction: 35QmCqWFzwJ1X2nm5M8rgExKEMbWTRqxCa1GryEsR595zYwBLqCzDowUYm3J2u13WMvYR2PRoS3eAMSzXfGvEVbe
- Confirmed: 0.5% SL / 0.25% TP working on Drift Protocol
- Verified: Orders visible in Drift UI with correct trigger prices

- Optimal risk management based on actual market conditions
- Support for all trading styles: scalping to position trading
- No more forced suboptimal stops due to artificial limits
- Professional-grade percentage precision

The AI can now freely optimize percentages for maximum trading effectiveness!
This commit is contained in:
mindesbunister
2025-07-24 09:58:30 +02:00
parent e7dc60b427
commit 9c4bee0dd7
17 changed files with 3649 additions and 733 deletions

View File

@@ -15,7 +15,6 @@ export interface AutomationConfig {
mode: 'SIMULATION' | 'LIVE'
symbol: string
timeframe: string
selectedTimeframes: string[] // Multi-timeframe support
tradingAmount: number
maxLeverage: number
stopLossPercent: number
@@ -63,9 +62,6 @@ export class AutomationService {
this.isRunning = true
console.log(`🤖 Starting automation for ${config.symbol} ${config.timeframe} in ${config.mode} mode`)
console.log(`📊 Using timeframes: ${config.selectedTimeframes?.join(", ") || "default fallback"}`)
console.log(`📊 Timeframes array:`, config.selectedTimeframes)
console.log(`🔧 Full config:`, JSON.stringify(config, null, 2))
// Ensure user exists in database
await prisma.user.upsert({
@@ -99,7 +95,6 @@ export class AutomationService {
timeframe: config.timeframe,
settings: {
tradingAmount: config.tradingAmount,
selectedTimeframes: config.selectedTimeframes,
maxLeverage: config.maxLeverage,
stopLossPercent: config.stopLossPercent,
takeProfitPercent: config.takeProfitPercent,
@@ -279,7 +274,7 @@ export class AutomationService {
progressTracker.updateStep(sessionId, 'init', 'active', 'Starting multi-timeframe analysis...')
// Multi-timeframe analysis: 15m, 1h, 2h, 4h
const timeframes = this.config!.selectedTimeframes && this.config!.selectedTimeframes.length > 0 ? this.config!.selectedTimeframes : ["15", "60", "120", "240"]
const timeframes = ['15', '1h', '2h', '4h']
const symbol = this.config!.symbol
console.log(`🔍 Analyzing ${symbol} across timeframes: ${timeframes.join(', ')} with AI + DIY layouts`)
@@ -598,12 +593,17 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
return null
}
// Log the trading signal
if (analysis.recommendation === "SELL") {
console.log("📉 SELL signal detected - Opening SHORT position")
} else if (analysis.recommendation === "BUY") {
console.log("📈 BUY signal detected - Opening LONG position")
// ✅ ENHANCED: Support both BUY and SELL signals
if (analysis.recommendation === 'SELL') {
// Check if we have SOL position to sell
const hasPosition = await this.checkCurrentPosition()
if (!hasPosition) {
console.log('📊 SELL signal but no SOL position to sell - skipping')
return null
}
console.log('📉 SELL signal detected with existing SOL position')
} else if (analysis.recommendation === 'BUY') {
console.log('📈 BUY signal detected')
}
// Calculate position size based on risk percentage
@@ -625,6 +625,40 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
}
}
// ✅ NEW: Check if we have SOL position available to sell
private async checkCurrentPosition(): Promise<boolean> {
try {
// Check recent trades to see current position
const recentTrades = await prisma.trade.findMany({
where: {
userId: this.config!.userId,
symbol: this.config!.symbol,
status: 'OPEN'
},
orderBy: { createdAt: 'desc' },
take: 5
})
// Count open positions
let netPosition = 0
for (const trade of recentTrades) {
if (trade.side === 'BUY') {
netPosition += trade.amount
} else if (trade.side === 'SELL') {
netPosition -= trade.amount
}
}
console.log(`🔍 Current SOL position: ${netPosition.toFixed(4)} SOL`)
return netPosition > 0.001 // Have at least 0.001 SOL to sell
} catch (error) {
console.error('❌ Error checking current position:', error)
// If we can't check, default to allowing the trade (fail-safe)
return true
}
}
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
@@ -771,7 +805,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)
}
@@ -818,53 +852,52 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
}
private async executeLiveTrade(decision: any): Promise<any> {
try {
console.log(`🚀 Executing DRIFT trade: ${decision.direction} ${decision.positionSize} ${this.config!.symbol} with ${this.config!.maxLeverage}x leverage`)
const response = await fetch("http://localhost:3000/api/automation/trade", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
dexProvider: "DRIFT",
action: decision.direction.toLowerCase() === "buy" ? "open_long" : "open_short",
symbol: this.config!.symbol.replace("USD", ""), // Convert SOLUSD to SOL
amount: this.config!.tradingAmount,
side: decision.direction,
leverage: this.config!.maxLeverage,
stopLoss: decision.stopLoss,
takeProfit: decision.takeProfit,
mode: "LIVE"
})
})
// Execute real trade via Jupiter DEX
const inputToken = decision.direction === 'BUY' ? 'USDC' : 'SOL'
const outputToken = decision.direction === 'BUY' ? 'SOL' : 'USDC'
const tokens = {
SOL: 'So11111111111111111111111111111111111111112',
USDC: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
}
if (!response.ok) {
throw new Error(`Drift trade request failed: ${response.statusText}`)
}
// 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`)
}
const result = await response.json()
if (result.success) {
return {
transactionId: result.result?.transactionId || result.txId,
executionPrice: result.result?.executionPrice || decision.currentPrice,
amount: result.result?.amount || decision.positionSize,
direction: decision.direction,
status: "COMPLETED",
timestamp: new Date(),
fees: result.result?.fees || 0,
slippage: result.result?.slippage || 0,
leverage: this.config!.maxLeverage,
dexProvider: "DRIFT",
tradingAmount: this.config!.tradingAmount
}
} else {
throw new Error(result.error || "Drift trade execution failed")
console.log(`🔄 Executing Jupiter swap with corrected amount: ${swapAmount}`)
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) {
return {
transactionId: swapResult.txId,
executionPrice: swapResult.executionPrice,
amount: swapResult.outputAmount, // Amount of tokens received
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
}
} catch (error) {
console.error("Live trade execution error:", error)
throw error
} else {
throw new Error(swapResult.error || 'Jupiter swap failed')
}
}
@@ -1072,7 +1105,6 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
mode: session.mode,
symbol: session.symbol,
timeframe: session.timeframe,
selectedTimeframes: settings.selectedTimeframes || ["60", "240"], // Default fallback
tradingAmount: settings.tradingAmount || 100,
maxLeverage: settings.maxLeverage || 3,
stopLossPercent: settings.stopLossPercent || 2,