# 📊 Comment le Bot Fixe les Prix d'Achat et de Vente

## 🎯 Vue d'ensemble

Le bot **n'utilise PAS d'ordres à prix fixe (limit orders)**. Il utilise principalement des **ordres au marché (market orders)** qui s'exécutent au prix actuel du marché.

---

## 💰 ACHAT - Mécanisme complet

### 1. Type d'ordre utilisé : **MARKET BUY**

```python
# Code: trading_bot.py ligne ~843
order = self.client.market_buy(symbol, usdt_amount)
```

**Qu'est-ce qu'un ordre MARKET ?**
- Achète **immédiatement** au meilleur prix disponible sur le marché
- Pas de prix fixe spécifié par le bot
- Le prix est celui que Binance propose **au moment de l'exécution**
- Garantit l'exécution, mais pas le prix exact

### 2. Fixation du montant d'achat

Le bot calcule le montant en **USDT** à investir :

```python
# Code: trading_bot.py ligne ~2550-2600
order_amount = INVESTMENT_PER_TRADE  # Par défaut: 50 USDT

# Ajustement selon le régime de marché
if regime_name == "BEAR":
    order_amount *= 0.5  # 25 USDT en marché baissier
elif regime_name == "NEUTRAL":
    order_amount *= 0.75  # 37.50 USDT en marché neutre
# BULL_WEAK/BULL_STRONG: 50 USDT (valeur par défaut)
```

**Paramètres :**
- `INVESTMENT_PER_TRADE = 50 USDT` (config.py ligne ~142)
- Réduit automatiquement dans les mauvaises conditions de marché
- Garantit une diversification (montant fixe par position)

### 3. Récupération du prix d'entrée réel

Après l'exécution de l'ordre :

```python
# Code: trading_bot.py ligne ~846-852
entry_price = float(order.get('fills', [{}])[0].get('price', 0))

# Si pas de prix dans les fills (rare)
if entry_price == 0:
    entry_price = self.client.get_price(symbol)
```

**Explication :**
- `fills` = détails des transactions qui ont rempli l'ordre
- Le prix d'entrée est celui **réellement payé** (peut varier de quelques centimes)
- Exemple : Tu demandes d'acheter pour 50 USDT, Binance achète au prix du marché (~0.3027 USDT/TRX par exemple)

### 4. Quantité achetée

```python
# Code: trading_bot.py ligne ~847
quantity = float(order.get('executedQty', 0))
```

La quantité est calculée automatiquement par Binance :
```
Quantité = Montant USDT / Prix du marché
Exemple: 50 USDT / 0.3027 USDT = 165.18 TRX
```

---

## 📈 STOP-LOSS & TAKE-PROFIT - Calcul automatique

### 1. Paramètres par défaut

```python
# config.py ligne ~125-130
STOP_LOSS_PERCENT = 2.5    # -2.5%
TAKE_PROFIT_PERCENT = 2.5  # +2.5%
```

**Ratio Risk/Reward :**
```
R/R = TP / SL = 2.5% / 2.5% = 1:1
(Pour chaque dollar risqué, tu peux gagner 1 dollar)
```

### 2. Calcul des niveaux SL/TP

```python
# Code: trading_bot.py ligne ~854-856
stop_loss = entry_price * (1 - stop_loss_pct / 100)
take_profit = entry_price * (1 + take_profit_pct / 100)

# Exemple avec TRX à 0.3027 USDT
# SL = 0.3027 * (1 - 2.5/100) = 0.3027 * 0.975 = 0.2951 USDT
# TP = 0.3027 * (1 + 2.5/100) = 0.3027 * 1.025 = 0.3103 USDT
```

**Stockage de la position :**
```python
self.positions[symbol] = {
    'entry_price': 0.3027,      # Prix d'achat réel
    'quantity': 165.18,         # Quantité achetée
    'stop_loss': 0.2951,        # -2.5%
    'take_profit': 0.3103,      # +2.5%
    'timestamp': datetime.now()
}
```

### 3. Ajustement dynamique selon le régime de marché

```python
# Code: trading_bot.py ligne ~2555-2590

# BEAR (marché baissier) - Très prudent
if regime_name == "BEAR":
    stop_loss_pct = 1.5     # SL serré (-1.5%)
    take_profit_pct = 4.0   # TP élevé (+4.0%)
    # R/R = 4.0/1.5 = 2.67 (gagner 2.67x ce qu'on risque)

# NEUTRAL (marché neutre) - Équilibré
elif regime_name == "NEUTRAL":
    stop_loss_pct = 2.0     # -2.0%
    take_profit_pct = 3.0   # +3.0%
    # R/R = 3.0/2.0 = 1.5

# BULL (marché haussier) - Laisser courir
else:  # BULL_WEAK ou BULL_STRONG
    stop_loss_pct = 2.5     # -2.5% (défaut)
    take_profit_pct = 2.5   # +2.5% (défaut)
```

**Pourquoi ces ajustements ?**
- **BEAR** : Risque élevé → SL serré + TP large pour compenser
- **NEUTRAL** : Équilibre entre protection et profit
- **BULL** : Confiance élevée → Laisser courir les gains

---

## 🔴 VENTE - Mécanisme complet

### 1. Type d'ordre : **MARKET SELL**

```python
# Code: trading_bot.py ligne ~906
order = self.client.market_sell(symbol, quantity)
```

**Caractéristiques :**
- Vend **immédiatement** au meilleur prix du marché
- Exécution garantie (important pour les stop-loss urgents)
- Prix de sortie = celui proposé par Binance au moment T

### 2. Conditions de vente automatique

Le bot surveille **en continu** (toutes les 10 secondes) et vend automatiquement si :

#### A. **TAKE-PROFIT atteint** (objectif de gain)

```python
# Code: trading_bot.py ligne ~1388-1390
if current_price >= position['take_profit']:
    print(f"🟢 TAKE-PROFIT: {symbol}")
    self.close_position(symbol, "take-profit")
```

**Exemple :**
```
Entry: 0.3027 USDT
TP: 0.3103 USDT (+2.5%)
Prix actuel: 0.3105 USDT
→ VENTE automatique ✅
```

#### B. **STOP-LOSS touché** (protection contre les pertes)

```python
# Code: trading_bot.py ligne ~1373-1382
if current_price <= position['stop_loss']:
    if current_pnl_pct > 0:
        print(f"🟡 TRAILING STOP")  # Vente avec profit
    else:
        print(f"🔴 STOP-LOSS")       # Vente avec perte
    self.close_position(symbol, "stop-loss")
```

**Exemple :**
```
Entry: 0.3027 USDT
SL: 0.2951 USDT (-2.5%)
Prix actuel: 0.2945 USDT
→ VENTE automatique ❌
```

#### C. **STOP-LOSS D'URGENCE** (-5%)

```python
# Code: trading_bot.py ligne ~1323-1325
if current_pnl_pct <= -5:
    print(f"🚨 STOP-LOSS D'URGENCE")
    self.close_position(symbol, "stop-loss-urgence")
```

Protection supplémentaire en cas de chute brutale.

#### D. **Stratégie BB+ BREAKOUT** (vente sur sortie de tendance)

```python
# Code: trading_bot.py ligne ~1243-1310
if position.get('bb_breakout_entry', False):
    if current_price < bb_upper:
        # Vérifier le momentum
        if momentum_3 < -0.3:  # Baisse active
            self.close_position(symbol, "bb-breakout-exit")
```

**Explication :**
- Positions achetées sur breakout BB+ (dépassement bande Bollinger supérieure)
- Vendues dès que le prix repasse sous BB+ **ET** momentum négatif
- Capture les rallyes de courte durée

#### E. **Trailing Stop** (protection des gains)

```python
# Code: trading_bot.py ligne ~1203-1235

# Palier 1: +50% du TP → Stop au break-even
if current_pnl_pct >= tp_pct * 0.5:
    breakeven_stop = entry_price * 1.001  # +0.1%
    position['stop_loss'] = breakeven_stop

# Palier 2: +75% du TP → Protéger 50% des gains
if current_pnl_pct >= tp_pct * 0.75:
    protect_stop = entry_price * (1 + current_pnl_pct * 0.5 / 100)
    position['stop_loss'] = protect_stop
```

**Exemple concret :**
```
Entry: 100 USDT
TP: 102.5 USDT (+2.5%)

Scénario 1: Prix monte à 101.25 (+1.25%, 50% du TP)
→ SL ajusté à 100.1 USDT (break-even)
→ Plus de risque de perte !

Scénario 2: Prix monte à 101.875 (+1.875%, 75% du TP)
→ SL ajusté à 100.9375 USDT (protège 50% des gains)
→ Gain minimum garanti: +0.9375%
```

---

## 🔄 Cycle complet d'une position

### Étape 1 : CONDITIONS D'ACHAT

Le bot achète si **toutes** ces conditions sont réunies :

```python
# Code: trading_bot.py ligne ~2340-2365

1. buy_signals >= 5 points (minimum requis)
   - RSI < 35 : +3 points (survendu)
   - Prix < BB- : +3 points (sous bande Bollinger basse)
   - EMA9 < EMA21 : +2 points (momentum baissier = opportunité)
   - Volume anormal : +1 point
   - Etc.

2. current_positions < max_positions
   - Maximum 20 positions ouvertes simultanément

3. Pas de cooldown actif
   - 5 minutes minimum entre 2 trades du même symbole

4. Montant suffisant
   - Minimum 10 USDT disponibles

5. Max 5 achats par heure
   - Protection anti-concentration temporelle
```

### Étape 2 : EXÉCUTION ACHAT

```python
1. Calcul du montant: 50 USDT (ou ajusté selon régime)
2. Ordre MARKET: Acheter au prix du marché
3. Binance exécute: Prix = 0.3027, Quantité = 165.18 TRX
4. Calcul SL/TP:
   - SL = 0.2951 (-2.5%)
   - TP = 0.3103 (+2.5%)
5. Sauvegarde de la position dans positions.json
```

### Étape 3 : SURVEILLANCE (toutes les 10 secondes)

```python
# Code: trading_bot.py ligne ~1160-1390

for symbol, position in positions.items():
    current_price = get_current_market_price(symbol)
    
    # Vérification 1: Stop-Loss d'urgence
    if pnl_pct <= -5%:
        → VENTE IMMÉDIATE
    
    # Vérification 2: Stop-Loss normal
    elif current_price <= SL:
        → VENTE IMMÉDIATE
    
    # Vérification 3: Take-Profit
    elif current_price >= TP:
        → VENTE IMMÉDIATE
    
    # Vérification 4: Trailing Stop (ajustements)
    if 50% du TP atteint:
        → Ajuster SL au break-even
    if 75% du TP atteint:
        → Protéger 50% des gains
    
    # Vérification 5: Stratégies spéciales
    if BB+ Breakout:
        → Vente si prix < BB+ + momentum négatif
```

### Étape 4 : EXÉCUTION VENTE

```python
1. Trigger détecté (TP, SL, ou autre)
2. Ordre MARKET SELL: Vendre au prix du marché
3. Binance exécute: Prix de sortie = 0.3105
4. Calcul P&L:
   - Entry: 0.3027 × 165.18 = 50 USDT
   - Exit: 0.3105 × 165.18 = 51.29 USDT
   - Profit: +1.29 USDT (+2.58%)
5. Sauvegarde dans trade_history
6. Suppression de positions.json
```

---

## 📊 Exemples réels de calcul de prix

### Exemple 1 : Trade gagnant (TRX)

```
══════════════════════════════════════════════════════════
ACHAT
══════════════════════════════════════════════════════════
Montant investi: 50 USDT
Prix d'entrée: 0.3027 USDT/TRX (prix du marché au moment T)
Quantité achetée: 50 / 0.3027 = 165.18 TRX

Calculs automatiques:
- Stop-Loss: 0.3027 × 0.975 = 0.2951 USDT
- Take-Profit: 0.3027 × 1.025 = 0.3103 USDT

══════════════════════════════════════════════════════════
SURVEILLANCE (toutes les 10 secondes)
══════════════════════════════════════════════════════════
t=0s : Prix = 0.3027 (entry) | P&L = 0%
t=10s: Prix = 0.3045 (+0.59%) | Rien à faire
t=20s: Prix = 0.3078 (+1.68%) | 50% du TP → SL ajusté à 0.3030 (break-even)
t=30s: Prix = 0.3105 (+2.58%) | TP atteint!

══════════════════════════════════════════════════════════
VENTE AUTOMATIQUE (TAKE-PROFIT)
══════════════════════════════════════════════════════════
Prix de sortie: 0.3105 USDT (prix du marché au moment de la vente)
Valeur vendue: 0.3105 × 165.18 = 51.29 USDT
Profit net: 51.29 - 50 = +1.29 USDT (+2.58%)
```

### Exemple 2 : Trade perdant (SSV)

```
══════════════════════════════════════════════════════════
ACHAT
══════════════════════════════════════════════════════════
Montant investi: 50 USDT
Prix d'entrée: 4.243 USDT/SSV
Quantité achetée: 50 / 4.243 = 11.785 SSV

Calculs:
- Stop-Loss: 4.243 × 0.975 = 4.137 USDT
- Take-Profit: 4.243 × 1.025 = 4.349 USDT

══════════════════════════════════════════════════════════
SURVEILLANCE
══════════════════════════════════════════════════════════
t=0s : Prix = 4.243 (entry) | P&L = 0%
t=10s: Prix = 4.198 (-1.06%) | Rien à faire
t=20s: Prix = 4.154 (-2.10%) | Proche du SL
t=30s: Prix = 4.125 (-2.78%) | STOP-LOSS DÉCLENCHÉ!

══════════════════════════════════════════════════════════
VENTE AUTOMATIQUE (STOP-LOSS)
══════════════════════════════════════════════════════════
Prix de sortie: 4.125 USDT
Valeur vendue: 4.125 × 11.785 = 48.61 USDT
Perte nette: 48.61 - 50 = -1.39 USDT (-2.78%)
```

---

## 🎯 Pourquoi des ordres MARKET et non LIMIT ?

### Ordre MARKET (utilisé par le bot)

**Avantages :**
- ✅ Exécution **garantie immédiate**
- ✅ Pas de risque de "rate l'occasion"
- ✅ Simple à implémenter
- ✅ Idéal pour les stop-loss (urgence)

**Inconvénients :**
- ❌ Prix exact non garanti (slippage possible)
- ❌ Peut être légèrement défavorable en marché volatile

### Ordre LIMIT (non utilisé)

**Avantages :**
- ✅ Prix exact garanti
- ✅ Contrôle total du prix d'exécution

**Inconvénients :**
- ❌ Peut **ne jamais s'exécuter** si le prix ne revient pas
- ❌ Rate des opportunités (prix demandé trop bas/élevé)
- ❌ Complexe à gérer (expiration, annulation, re-création)

**Choix du bot : MARKET**
Pour un bot automatique, la **garantie d'exécution** est plus importante que le contrôle précis du prix. Le slippage (différence entre prix attendu et réel) est généralement de 0.01-0.1% sur les cryptos liquides, ce qui est négligeable.

---

## 🔧 Configuration des paramètres de prix

Tous les paramètres sont modifiables dans `config.py` :

```python
# config.py lignes 125-145

# ═══════════════════════════════════════════════════════════
# PARAMÈTRES DE TRADING
# ═══════════════════════════════════════════════════════════

INVESTMENT_PER_TRADE = 50.0     # Montant par trade (USDT)
STOP_LOSS_PERCENT = 2.5         # Stop-loss (-2.5%)
TAKE_PROFIT_PERCENT = 2.5       # Take-profit (+2.5%)
MAX_OPEN_POSITIONS = 20         # Maximum de positions simultanées

# Cooldowns
TRADE_COOLDOWN = 300            # 5 minutes entre 2 trades même symbole
SIGNAL_COOLDOWN = 30            # 30 secondes entre 2 signaux

# Limites
MIN_ORDER_SIZE = 10.0           # Montant minimum par ordre (USDT)
MAX_BUYS_PER_HOUR = 5           # Maximum 5 achats par heure
```

**Pour modifier :**
1. Ouvrir `config.py`
2. Changer les valeurs
3. Redémarrer le bot : `python Reset_trading.py`

**Exemples de modifications :**
```python
# Plus agressif (risque élevé)
STOP_LOSS_PERCENT = 3.0
TAKE_PROFIT_PERCENT = 5.0
INVESTMENT_PER_TRADE = 100.0

# Plus conservateur (risque faible)
STOP_LOSS_PERCENT = 1.5
TAKE_PROFIT_PERCENT = 2.0
INVESTMENT_PER_TRADE = 25.0
```

---

## 📈 Récapitulatif - Où est fixé le prix ?

| Élément | Fixé par | Méthode | Modifiable ? |
|---------|----------|---------|--------------|
| **Prix d'achat** | Binance (marché) | Ordre MARKET | ❌ Non (prix du marché) |
| **Montant investi** | Bot (config) | 50 USDT par défaut | ✅ Oui (config.py) |
| **Quantité achetée** | Binance (calcul) | Montant / Prix | ❌ Non (automatique) |
| **Stop-Loss** | Bot (calcul) | Entry × (1 - SL%) | ✅ Oui (config.py SL%) |
| **Take-Profit** | Bot (calcul) | Entry × (1 + TP%) | ✅ Oui (config.py TP%) |
| **Prix de vente** | Binance (marché) | Ordre MARKET | ❌ Non (prix du marché) |
| **Trailing Stop** | Bot (dynamique) | Ajusté selon P&L | ✅ Oui (logique code) |

---

## 🎓 Points clés à retenir

1. **Le bot ne fixe PAS les prix d'achat/vente** → Il utilise le prix du marché au moment T
2. **Le bot fixe les NIVEAUX de sortie** (SL/TP) → Calculés en % du prix d'entrée
3. **Les ordres sont MARKET** → Exécution garantie, prix non garanti (mais proche)
4. **Les paramètres sont configurables** → Ajuster SL/TP/montant selon ton profil de risque
5. **La surveillance est continue** → Toutes les 10 secondes, le bot vérifie les conditions
6. **Protection multi-niveaux** → SL urgence, SL normal, trailing stop, stratégies spéciales

---

## 🔍 Où trouver les infos dans le code ?

| Fonction | Fichier | Ligne | Description |
|----------|---------|-------|-------------|
| `market_buy()` | trading_bot.py | ~843 | Exécution achat MARKET |
| `market_sell()` | trading_bot.py | ~906 | Exécution vente MARKET |
| `open_position()` | trading_bot.py | ~820-880 | Calcul SL/TP à l'achat |
| `check_positions()` | trading_bot.py | ~1160-1390 | Surveillance des positions |
| `close_position()` | trading_bot.py | ~884-993 | Exécution de la vente |
| Trailing Stop | trading_bot.py | ~1203-1235 | Ajustement dynamique SL |
| Paramètres | config.py | ~125-145 | Configuration SL/TP/montant |

---

**Version :** 1.0  
**Date :** 13 janvier 2026  
**Auteur :** Documentation du système de trading