Trader.py

import ccxt
import time
import numpy as np
import pandas as pd
import tensorflow as tf  # Assuming you are using TensorFlow for the CNN model
from sqlite3 import connect
from sklearn.preprocessing import StandardScaler

# Set up the Binance client
api_key = 'YOUR_API_KEY'
api_secret = 'YOUR_API_SECRET'

exchange = ccxt.binance({
    'apiKey': api_key,
    'secret': api_secret,
    'enableRateLimit': True,
    'options': {'defaultType': 'future'}  # for futures trading
})

# Define the trading symbols
symbols = ['BTC/USDT', 'ETH/USDT', 'BNB/USDT', 'SOL/USDT', 'XRP/USDT']

# CNN Model Path (assuming pre-trained model)
model_path = 'path_to_your_trained_cnn_model.h5'
cnn_model = tf.keras.models.load_model(model_path)

# Initialize the scaler for normalization
scaler = StandardScaler()

# Database for storing trades
db = connect('trades.db')
cursor = db.cursor()
cursor.execute('''CREATE TABLE IF NOT EXISTS trades (symbol TEXT, order_id TEXT, type TEXT, price REAL, amount REAL, status TEXT)''')

# Function to fetch OHLCV data and compute technical indicators (with rate-limiting)
def fetch_data(symbol, timeframe='1h', limit=100):
    try:
        # Fetch OHLCV data from Binance
        ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
        df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
        
        # Compute technical indicators
        df['rsi'] = compute_rsi(df['close'])
        df['adx'] = compute_adx(df)
        df['atr'] = compute_atr(df)
        df['vwap'] = compute_vwap(df)
        df['taker_ratio'] = compute_taker_ratio(df)  # Custom function to calculate Taker Ratio
        return df
    except Exception as e:
        print(f"Error fetching data for {symbol}: {str(e)}")
        return None

# Compute RSI
def compute_rsi(data, period=14):
    delta = data.diff()
    gain = delta.where(delta > 0, 0)
    loss = -delta.where(delta < 0, 0)
    avg_gain = gain.rolling(window=period).mean()
    avg_loss = loss.rolling(window=period).mean()
    rs = avg_gain / avg_loss
    return 100 - (100 / (1 + rs))

# Compute ADX
def compute_adx(df, period=14):
    high = df['high']
    low = df['low']
    close = df['close']
    tr = np.maximum(high - low, np.abs(high - close.shift(1)), np.abs(low - close.shift(1)))
    atr = tr.rolling(window=period).mean()
    return atr

# Compute ATR
def compute_atr(df, period=14):
    df['tr'] = np.maximum(df['high'] - df['low'], np.abs(df['high'] - df['close'].shift(1)), np.abs(df['low'] - df['close'].shift(1)))
    return df['tr'].rolling(window=period).mean()

# Compute VWAP
def compute_vwap(df):
    df['vwap'] = (df['volume'] * df['close']).cumsum() / df['volume'].cumsum()
    return df['vwap']

# Compute Taker Ratio (Custom Indicator)
def compute_taker_ratio(df):
    return df['volume'] / df['volume'].mean()

# Preprocess the data for CNN
def preprocess_data(df):
    features = df[['rsi', 'adx', 'atr', 'vwap', 'taker_ratio']].values[-20:]
    return scaler.fit_transform(features)

# Make Prediction using the CNN model
def predict_price_move(preprocessed_data):
    prediction = cnn_model.predict(np.expand_dims(preprocessed_data, axis=0))
    return prediction[0]  # Assume model returns a probability or regression output

# Place an order on Binance
def place_order(symbol, side, amount, price):
    if side == 'buy':
        order = exchange.create_market_buy_order(symbol, amount)
    elif side == 'sell':
        order = exchange.create_market_sell_order(symbol, amount)
    return order

# Risk management using SMC concepts for SL and ATR for TP
def calculate_smc_stop_loss(df, entry_price):
    # For simplicity, assume we use a basic market structure (HH/HL or LH/LL) to determine the stop loss
    # Example SMC-based: Stop below the last swing low if uptrend (HH/HL)
    last_low = df['low'].min()  # Example of low for simplicity
    return last_low * 0.99  # Stop-loss 1% below the last swing low

def calculate_atr_take_profit(df, entry_price):
    atr = df['atr'].iloc[-1]  # Most recent ATR value
    return entry_price + 2 * atr  # TP at 2x ATR above entry price

# Trade Management Loop
def trading_loop():
    for symbol in symbols:
        df = fetch_data(symbol)
        if df is None:
            continue
        
        preprocessed_data = preprocess_data(df)
        prediction = predict_price_move(preprocessed_data)

        # Check if the CNN model predicts a significant move (example threshold)
        if prediction > 0.5:  # If the probability of a price move exceeds 50%
            entry_price = df['close'].iloc[-1]
            stop_loss = calculate_smc_stop_loss(df, entry_price)
            take_profit = calculate_atr_take_profit(df, entry_price)
            
            # Place a buy order (for simplicity, you could add a more complex strategy here)
            order = place_order(symbol, 'buy', 0.01, entry_price)  # Example: 0.01 BTC
            print(f"Placed buy order for {symbol} at {entry_price}.")

            # Risk management: Monitor stop-loss and take-profit
            while True:
                df = fetch_data(symbol)
                current_price = df['close'].iloc[-1]

                # Check if the price hits the stop-loss or take-profit
                if current_price <= stop_loss:
                    place_order(symbol, 'sell', 0.01, current_price)
                    print(f"Sell order triggered for {symbol} at {current_price}. Stop-loss hit.")
                    break
                elif current_price >= take_profit:
                    place_order(symbol, 'sell', 0.01, current_price)
                    print(f"Sell order triggered for {symbol} at {current_price}. Take-profit hit.")
                    break
                time.sleep(60)  # Wait a minute before checking again

        time.sleep(60)  # Sleep for a minute before checking the next symbol

# Main execution
if __name__ == '__main__':
    trading_loop()