import ccxt
import pandas as pd
import numpy as np
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1m"
GRID_LEVELS = 5  # Количество уровней сетки
GRID_SPACING = 100  # Расстояние между уровнями в $
BASE_PRICE = None  # Если None, берется текущая цена

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение текущей цены
def get_current_price(symbol):
    ticker = exchange.fetch_ticker(symbol)
    return ticker["last"]

# Генерация сетки ордеров
def generate_grid(base_price):
    buy_levels = [base_price - i * GRID_SPACING for i in range(1, GRID_LEVELS + 1)]
    sell_levels = [base_price + i * GRID_SPACING for i in range(1, GRID_LEVELS + 1)]
    return buy_levels, sell_levels

# Логика торговли по сетке
def grid_trading_bot():
    global BASE_PRICE
    if BASE_PRICE is None:
        BASE_PRICE = get_current_price(PAIR)

    buy_levels, sell_levels = generate_grid(BASE_PRICE)
    current_price = get_current_price(PAIR)

    print(f"Текущая цена: {current_price:.2f}")
    print(f"Уровни покупки: {buy_levels}")
    print(f"Уровни продажи: {sell_levels}")

    for level in buy_levels:
        if current_price <= level:
            print(f"📈 Цена достигла {level:.2f} → Сигнал на покупку!")

    for level in sell_levels:
        if current_price >= level:
            print(f"📉 Цена достигла {level:.2f} → Сигнал на продажу!")

# Запуск
if __name__ == "__main__":
    while True:
        grid_trading_bot()
        time.sleep(10)  # Проверка раз в 10 секунд

import ccxt
import pandas as pd
import talib
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
TENKAN_PERIOD = 9
KIJUN_PERIOD = 26
SENKOU_A_PERIOD = 26
SENKOU_B_PERIOD = 52

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=SENKOU_B_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет индикатора Ишимоку
def calculate_ichimoku(df):
    tenkan_sen = (df["high"].rolling(window=TENKAN_PERIOD).max() + df["low"].rolling(window=TENKAN_PERIOD).min()) / 2
    kijun_sen = (df["high"].rolling(window=KIJUN_PERIOD).max() + df["low"].rolling(window=KIJUN_PERIOD).min()) / 2
    senkou_span_a = ((tenkan_sen + kijun_sen) / 2).shift(SENKOU_A_PERIOD)
    senkou_span_b = ((df["high"].rolling(window=SENKOU_B_PERIOD).max() + df["low"].rolling(window=SENKOU_B_PERIOD).min()) / 2).shift(SENKOU_A_PERIOD)
    return tenkan_sen.iloc[-1], kijun_sen.iloc[-1], senkou_span_a.iloc[-1], senkou_span_b.iloc[-1], df["close"].iloc[-1]

# Логика сигналов
def ichimoku_cloud_strategy():
    df = fetch_ohlcv(PAIR)
    tenkan, kijun, senkou_a, senkou_b, close_price = calculate_ichimoku(df)

    print(f"Цена: {close_price:.2f}, Tenkan-sen: {tenkan:.2f}, Kijun-sen: {kijun:.2f}")
    print(f"Облако: Senkou A: {senkou_a:.2f}, Senkou B: {senkou_b:.2f}")

    if close_price > max(senkou_a, senkou_b):
        print("📈 Цена выше облака → сильный восходящий тренд (лонг).")
    elif close_price < min(senkou_a, senkou_b):
        print("📉 Цена ниже облака → сильный нисходящий тренд (шорт).")
    elif tenkan > kijun:
        print("📈 Tenkan-sen пересек Kijun-sen вверх → сигнал на покупку.")
    elif tenkan < kijun:
        print("📉 Tenkan-sen пересек Kijun-sen вниз → сигнал на продажу.")
    else:
        print("⚡ Нет четкого сигнала.")

# Запуск
if __name__ == "__main__":
    while True:
        ichimoku_cloud_strategy()
        time.sleep(60)  # Проверка раз в минуту

import ccxt
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
SPREAD = 0.1  # Размер спреда в процентах
ORDER_SIZE = 0.001  # Размер заявки
CHECK_INTERVAL = 10  # Частота проверки (секунды)

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение текущих цен бид/аск
def get_order_book(symbol):
    order_book = exchange.fetch_order_book(symbol)
    bid = order_book["bids"][0][0]  # Лучшая цена покупки
    ask = order_book["asks"][0][0]  # Лучшая цена продажи
    return bid, ask

# Логика маркет-мейкинга
def market_making_bot():
    bid, ask = get_order_book(PAIR)
    spread_value = (ask - bid) / bid * 100  # Спред в %

    # Рассчет уровней размещения ордеров
    buy_price = bid * (1 - SPREAD / 100)
    sell_price = ask * (1 + SPREAD / 100)

    print(f"Бид: {bid:.2f}, Аск: {ask:.2f}, Спред: {spread_value:.2f}%")
    print(f"📥 Разместить заявку на покупку по: {buy_price:.2f}")
    print(f"📤 Разместить заявку на продажу по: {sell_price:.2f}")

# Запуск
if __name__ == "__main__":
    while True:
        market_making_bot()
        time.sleep(CHECK_INTERVAL)

import ccxt
import pandas as pd
import talib
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
SAR_ACCELERATION = 0.02  # Начальное ускорение
SAR_MAX_ACCELERATION = 0.2  # Максимальное ускорение

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=50)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет Parabolic SAR
def calculate_sar(df):
    sar = talib.SAR(df["high"], df["low"], acceleration=SAR_ACCELERATION, maximum=SAR_MAX_ACCELERATION)
    return sar.iloc[-1], df["close"].iloc[-1]

# Логика сигналов
def parabolic_sar_strategy():
    df = fetch_ohlcv(PAIR)
    sar, close_price = calculate_sar(df)

    print(f"Цена: {close_price:.2f}, SAR: {sar:.2f}")

    if close_price > sar:
        print("📈 SAR ниже цены → восходящий тренд (лонг).")
    elif close_price < sar:
        print("📉 SAR выше цены → нисходящий тренд (шорт).")
    else:
        print("⚡ Нет четкого сигнала.")

# Запуск
if __name__ == "__main__":
    while True:
        parabolic_sar_strategy()
        time.sleep(60)  # Проверка раз в минуту

import ccxt
import time

# Параметры
PAIR = "BTC/USDT"
SPREAD_THRESHOLD = 0.5  # Минимальная разница в % для арбитража
CHECK_INTERVAL = 10  # Проверка раз в 10 секунд

# Инициализация бирж
binance = ccxt.binance()
kucoin = ccxt.kucoin()

# Получение цены с бирж
def get_price(exchange, symbol):
    try:
        ticker = exchange.fetch_ticker(symbol)
        return ticker["last"]
    except Exception as e:
        print(f"Ошибка при получении цены с {exchange.id}: {e}")
        return None

# Логика арбитража
def arbitrage_bot():
    binance_price = get_price(binance, PAIR)
    kucoin_price = get_price(kucoin, PAIR)

    if binance_price and kucoin_price:
        spread = (abs(binance_price - kucoin_price) / min(binance_price, kucoin_price)) * 100

        print(f"Binance: {binance_price:.2f}, KuCoin: {kucoin_price:.2f}, Spread: {spread:.2f}%")

        if spread > SPREAD_THRESHOLD:
            if binance_price < kucoin_price:
                print(f"📈 Арбитраж: Покупка на Binance ({binance_price:.2f}), продажа на KuCoin ({kucoin_price:.2f})")
            else:
                print(f"📉 Арбитраж: Покупка на KuCoin ({kucoin_price:.2f}), продажа на Binance ({binance_price:.2f})")
        else:
            print("⚡ Нет арбитражных возможностей.")

# Запуск
if __name__ == "__main__":
    while True:
        arbitrage_bot()
        time.sleep(CHECK_INTERVAL)

import ccxt
import pandas as pd
import talib
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
ATR_PERIOD = 14  # Период ATR
VOLATILITY_THRESHOLD = 100  # Минимальное значение ATR для торговли

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=ATR_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет ATR
def calculate_atr(df):
    atr = talib.ATR(df["high"], df["low"], df["close"], timeperiod=ATR_PERIOD).iloc[-1]
    return atr

# Логика фильтрации волатильности
def atr_volatility_filter():
    df = fetch_ohlcv(PAIR)
    atr = calculate_atr(df)
    price = df["close"].iloc[-1]

    print(f"Цена: {price:.2f}, ATR: {atr:.2f}")

    if atr > VOLATILITY_THRESHOLD:
        print("📊 Высокая волатильность → торговля разрешена.")
    else:
        print("⚠️ Волатильность низкая → торговля не рекомендуется.")

# Запуск
if __name__ == "__main__":
    while True:
        atr_volatility_filter()
        time.sleep(60)  # Проверка раз в минуту

import ccxt
import time

# Параметры
EXCHANGE_NAME = "binance"
BASE_CURRENCY = "USDT"  # Начальная и конечная валюта
TRADE_PAIRS = [("BTC/USDT", "BTC", "USDT"), 
               ("ETH/BTC", "ETH", "BTC"), 
               ("ETH/USDT", "USDT", "ETH")]  # Трехугольный цикл
PROFIT_THRESHOLD = 0.5  # Минимальная прибыль в % для арбитража
CHECK_INTERVAL = 10  # Проверка раз в 10 секунд

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение цены пары
def get_price(pair):
    try:
        ticker = exchange.fetch_ticker(pair)
        return ticker["last"]
    except Exception as e:
        print(f"Ошибка получения цены {pair}: {e}")
        return None

# Логика арбитража
def triangular_arbitrage():
    try:
        # Получаем цены для трех пар
        price_a = get_price(TRADE_PAIRS[0][0])  # BTC/USDT
        price_b = get_price(TRADE_PAIRS[1][0])  # ETH/BTC
        price_c = get_price(TRADE_PAIRS[2][0])  # ETH/USDT

        if price_a and price_b and price_c:
            # Вычисляем итоговую прибыль
            start_amount = 1  # Допустим, начинаем с 1 USDT
            step1 = start_amount / price_a  # Покупаем BTC
            step2 = step1 / price_b  # Обмениваем BTC на ETH
            final_amount = step2 * price_c  # Обмениваем ETH обратно в USDT
            profit = ((final_amount - start_amount) / start_amount) * 100

            print(f"Цены: BTC/USDT={price_a:.2f}, ETH/BTC={price_b:.6f}, ETH/USDT={price_c:.2f}")
            print(f"Ожидаемая прибыль: {profit:.2f}%")

            if profit > PROFIT_THRESHOLD:
                print(f"📈 Возможность арбитража! Прибыль: {profit:.2f}%")
            else:
                print("⚡ Нет арбитражной возможности.")

    except Exception as e:
        print(f"Ошибка в арбитраже: {e}")

# Запуск
if __name__ == "__main__":
    while True:
        triangular_arbitrage()
        time.sleep(CHECK_INTERVAL)

import ccxt
import pandas as pd
import talib
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
RSI_PERIOD = 14
MACD_FAST = 12
MACD_SLOW = 26
MACD_SIGNAL = 9
BB_PERIOD = 20
BB_STD_DEV = 2

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=BB_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет индикаторов
def calculate_indicators(df):
    rsi = talib.RSI(df["close"], timeperiod=RSI_PERIOD).iloc[-1]
    macd, signal, _ = talib.MACD(df["close"], fastperiod=MACD_FAST, slowperiod=MACD_SLOW, signalperiod=MACD_SIGNAL)
    upper, middle, lower = talib.BBANDS(df["close"], timeperiod=BB_PERIOD, nbdevup=BB_STD_DEV, nbdevdn=BB_STD_DEV)

    return rsi, macd.iloc[-1], signal.iloc[-1], upper.iloc[-1], middle.iloc[-1], lower.iloc[-1], df["close"].iloc[-1]

# Логика сигналов
def multi_indi_scanner():
    df = fetch_ohlcv(PAIR)
    rsi, macd, signal, upper, middle, lower, close_price = calculate_indicators(df)

    print(f"Цена: {close_price:.2f}, RSI: {rsi:.2f}, MACD: {macd:.2f}, Signal: {signal:.2f}")
    print(f"Bollinger Bands → Верхняя: {upper:.2f}, Средняя: {middle:.2f}, Нижняя: {lower:.2f}")

    buy_signal = rsi < 30 and macd > signal and close_price < lower
    sell_signal = rsi > 70 and macd < signal and close_price > upper

    if buy_signal:
        print("📈 Сильный сигнал на покупку (LONG)!")
    elif sell_signal:
        print("📉 Сильный сигнал на продажу (SHORT)!")
    else:
        print("⚡ Нет четкого сигнала.")

# Запуск
if __name__ == "__main__":
    while True:
        multi_indi_scanner()
        time.sleep(60)  # Проверка раз в минуту

import ccxt
import pandas as pd
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1m"  # Торговля на коротких таймфреймах
VWAP_PERIOD = 20  # Количество свечей для расчета VWAP
CHECK_INTERVAL = 10  # Проверка раз в 10 секунд

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=VWAP_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет VWAP
def calculate_vwap(df):
    typical_price = (df["high"] + df["low"] + df["close"]) / 3
    vwap = (typical_price * df["volume"]).cumsum() / df["volume"].cumsum()
    return vwap.iloc[-1]

# Логика торговли по VWAP
def vwap_trading_bot():
    df = fetch_ohlcv(PAIR)
    vwap = calculate_vwap(df)
    close_price = df["close"].iloc[-1]

    print(f"Цена: {close_price:.2f}, VWAP: {vwap:.2f}")

    if close_price > vwap:
        print("📈 Цена выше VWAP → рынок бычий (лонг при откатах).")
    elif close_price < vwap:
        print("📉 Цена ниже VWAP → рынок медвежий (шорт при откатах).")
    else:
        print("⚡ Цена у VWAP, неопределенность.")

# Запуск
if __name__ == "__main__":
    while True:
        vwap_trading_bot()
        time.sleep(CHECK_INTERVAL)

import ccxt
import time
from datetime import datetime, timedelta

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
DCA_AMOUNT = 100  # Сумма покупки в USDT
DCA_INTERVAL = 7  # Количество дней между покупками
CHECK_INTERVAL = 86400  # Проверка раз в день (86400 секунд)

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# История покупок
dca_history = []

# Получение текущей цены
def get_current_price(symbol):
    ticker = exchange.fetch_ticker(symbol)
    return ticker["last"]

# Логика DCA
def dca_bot():
    global dca_history
    current_price = get_current_price(PAIR)
    now = datetime.now()

    # Проверяем, когда была последняя покупка
    if not dca_history or (now - dca_history[-1]["time"]).days >= DCA_INTERVAL:
        dca_history.append({"time": now, "price": current_price, "amount": DCA_AMOUNT})
        print(f"📥 DCA покупка: {DCA_AMOUNT} USDT по цене {current_price:.2f}")

    # Вывод истории покупок
    print("📊 История DCA-покупок:")
    for entry in dca_history:
        print(f"{entry['time'].strftime('%Y-%m-%d %H:%M')} → {entry['amount']} USDT по {entry['price']:.2f}")

# Запуск
if __name__ == "__main__":
    while True:
        dca_bot()
        time.sleep(CHECK_INTERVAL)  # Проверка раз в день

import ccxt
import pandas as pd
import talib
import time
import xgboost as xgb
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
TRAIN_SIZE = 200  # Количество свечей для обучения
FEATURES = ["rsi", "macd", "boll_upper", "boll_lower", "volume", "atr"]

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение исторических данных
def fetch_ohlcv(symbol, limit=TRAIN_SIZE + 50):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=limit)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Генерация признаков
def generate_features(df):
    df["rsi"] = talib.RSI(df["close"], timeperiod=14)
    macd, signal, _ = talib.MACD(df["close"], fastperiod=12, slowperiod=26, signalperiod=9)
    df["macd"] = macd - signal
    upper, _, lower = talib.BBANDS(df["close"], timeperiod=20, nbdevup=2, nbdevdn=2)
    df["boll_upper"] = upper
    df["boll_lower"] = lower
    df["atr"] = talib.ATR(df["high"], df["low"], df["close"], timeperiod=14)
    df.dropna(inplace=True)
    return df

# Создание метки для предсказания
def generate_labels(df):
    df["target"] = np.where(df["close"].shift(-1) > df["close"], 1, 0)  # 1 = рост, 0 = падение
    return df

# Обучение модели
def train_model(df):
    X = df[FEATURES]
    y = df["target"]
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)
    
    model = xgb.XGBClassifier(use_label_encoder=False, eval_metric="logloss")
    model.fit(X_train, y_train)
    
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    print(f"🔹 Точность модели: {accuracy:.2f}")
    
    return model

# Логика прогнозирования
def ai_trading_bot(model):
    df = fetch_ohlcv(PAIR)
    df = generate_features(df)
    X_live = df[FEATURES].iloc[-1:].values
    prediction = model.predict(X_live)[0]
    
    print(f"🔹 Прогноз: {'📈 Лонг' if prediction == 1 else '📉 Шорт'}")

# Запуск
if __name__ == "__main__":
    df = fetch_ohlcv(PAIR)
    df = generate_features(df)
    df = generate_labels(df)
    model = train_model(df)

    while True:
        ai_trading_bot(model)
        time.sleep(60)  # Проверка раз в минуту

import ccxt
import pandas as pd
import talib
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
LOOKBACK_PERIOD = 10  # Количество свечей для анализа дивергенции
CHECK_INTERVAL = 60  # Проверка раз в минуту

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=LOOKBACK_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет OBV
def calculate_obv(df):
    obv = talib.OBV(df["close"], df["volume"])
    return obv

# Проверка дивергенций
def detect_obv_divergence():
    df = fetch_ohlcv(PAIR)
    df["obv"] = calculate_obv(df)

    # Анализ цен и OBV на последних 10 свечах
    price_min = df["close"].iloc[-LOOKBACK_PERIOD:].min()
    price_max = df["close"].iloc[-LOOKBACK_PERIOD:].max()
    obv_min = df["obv"].iloc[-LOOKBACK_PERIOD:].min()
    obv_max = df["obv"].iloc[-LOOKBACK_PERIOD:].max()
    current_price = df["close"].iloc[-1]
    current_obv = df["obv"].iloc[-1]

    print(f"Цена: {current_price:.2f}, OBV: {current_obv:.2f}")

    if price_min < current_price and obv_min > current_obv:
        print("📈 Бычья дивергенция! Возможен рост (лонг).")
    elif price_max > current_price and obv_max < current_obv:
        print("📉 Медвежья дивергенция! Возможен спад (шорт).")
    else:
        print("⚡ Нет четкого сигнала.")

# Запуск
if __name__ == "__main__":
    while True:
        detect_obv_divergence()
        time.sleep(CHECK_INTERVAL)

import ccxt
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TRAILING_PERCENT = 2  # На сколько % ниже максимальной цены ставится стоп-лосс
CHECK_INTERVAL = 10  # Проверка раз в 10 секунд

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Текущее состояние
max_price = None
stop_loss = None

# Получение текущей цены
def get_current_price(symbol):
    ticker = exchange.fetch_ticker(symbol)
    return ticker["last"]

# Логика Trailing Stop
def trailing_stop_manager():
    global max_price, stop_loss
    current_price = get_current_price(PAIR)

    # Обновляем максимум цены
    if max_price is None or current_price > max_price:
        max_price = current_price
        stop_loss = max_price * (1 - TRAILING_PERCENT / 100)
        print(f"🔼 Новый максимум: {max_price:.2f}, стоп-лосс обновлен: {stop_loss:.2f}")

    # Проверяем, сработал ли стоп-лосс
    if stop_loss and current_price <= stop_loss:
        print(f"❌ Цена {current_price:.2f} достигла стоп-лосса {stop_loss:.2f} – сигнал на выход.")
        max_price, stop_loss = None, None  # Сбрасываем после срабатывания

# Запуск
if name == "main":
    while True:
        trailing_stop_manager()
        time.sleep(CHECK_INTERVAL)

import ccxt

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TRADE_AMOUNT = 0.001  # Количество актива для торговли
ENTRY_PRICE = 50000  # Цена покупки (можно заменить на реальную рыночную)
TAKE_PROFIT = 52000  # Цель по прибыли
STOP_LOSS = 48500  # Уровень стоп-лосса

# API-ключи (замените своими)
API_KEY = "your_api_key"
API_SECRET = "your_api_secret"

# Инициализация биржи
exchange = ccxt.binance({
    "apiKey": API_KEY,
    "secret": API_SECRET,
    "enableRateLimit": True,
})

# Установка OCO ордера
def place_oco_order():
    try:
        # Размещение OCO ордера (Take Profit + Stop Loss)
        order = exchange.create_order(
            symbol=PAIR,
            type="OCO",
            side="sell",
            amount=TRADE_AMOUNT,
            params={
                "stopPrice": STOP_LOSS,  # Уровень Stop Loss
                "price": TAKE_PROFIT,  # Уровень Take Profit
                "stopLimitPrice": STOP_LOSS - 50,  # Stop Limit (чуть ниже Stop Loss)
                "stopLimitTimeInForce": "GTC"  # Ордер действует до исполнения
            }
        )
        print("✅ OCO ордер успешно установлен:", order)
    except Exception as e:
        print("❌ Ошибка установки OCO ордера:", e)

# Запуск
if __name__ == "__main__":
    place_oco_order()