import ccxt
import time
from collections import deque

symbol = 'BTC/USDT'
exchange = ccxt.binance({'enableRateLimit': True})

WINDOW_SEC = 5
price_history = deque(maxlen=WINDOW_SEC)
position = None
entry_price = 0

print("Echo Rebound Strategy running...")

while True:
    ticker = exchange.fetch_ticker(symbol)
    price = ticker['last']
    price_history.append(price)
    
    if len(price_history) == WINDOW_SEC:
        p_now = price_history[-1]
        p_3s = price_history[-3]
        
        move = (p_now - p_3s) / p_3s

        # вход в шорт
        if move > 0.0025 and position is None:
            # ждём 2 сек — если high не обновился, значит импульс поглощён
            time.sleep(2)
            new_price = exchange.fetch_ticker(symbol)['last']
            if new_price <= price:
                position = 'short'
                entry_price = new_price
                print(f"📉 SHORT {symbol} at {entry_price:.2f} (echo down)")

        # вход в лонг
        elif move < -0.0025 and position is None:
            time.sleep(2)
            new_price = exchange.fetch_ticker(symbol)['last']
            if new_price >= price:
                position = 'long'
                entry_price = new_price
                print(f"📈 LONG {symbol} at {entry_price:.2f} (echo up)")

        # выход
        if position == 'long':
            if price >= entry_price * 1.0025:
                print(f"✅ Take profit LONG at {price:.2f}")
                position = None
            elif price <= entry_price * 0.9985:
                print(f"❌ Stop loss LONG at {price:.2f}")
                position = None

        elif position == 'short':
            if price <= entry_price * 0.9975:
                print(f"✅ Take profit SHORT at {price:.2f}")
                position = None
            elif price >= entry_price * 1.0015:
                print(f"❌ Stop loss SHORT at {price:.2f}")
                position = None

    time.sleep(1)

import ccxt
import time
import numpy as np

exchange = ccxt.binance({'enableRateLimit': True})
symbol = 'BTC/USDT'
prices = []

print(f"🔥 Запуск стратегии Micro Rebound Engine для {symbol}")

while True:
    ticker = exchange.fetch_ticker(symbol)
    price = ticker['last']
    prices.append(price)

    # Храним последние 20 цен
    if len(prices) > 20:
        prices.pop(0)

        recent_drop = (prices[-10] - prices[-1]) / prices[-10] * 100
        last_deltas = np.diff(prices[-5:])
        delta_change = np.mean(last_deltas[:-1]) - np.mean(last_deltas[-2:])

        if recent_drop <= -0.4 and delta_change > 0:
            entry = prices[-1]
            print(f"[LONG] Потенциальный микро-отскок: {entry}")
            t0 = time.time()

            while time.time() - t0 < 20:
                p = exchange.fetch_ticker(symbol)['last']
                if (p - entry) / entry * 100 >= 0.3:
                    print(f"[EXIT] Микро-профит зафиксирован: {p}")
                    break
                time.sleep(1)

    time.sleep(1)

import ccxt
import time
import numpy as np

exchange = ccxt.binance({'enableRateLimit': True})
symbols = [s['symbol'] for s in exchange.load_markets().values() if '/USDT' in s['symbol']]

price_data = {s: [] for s in symbols}
volume_data = {s: [] for s in symbols}

print("🔥 Volatility Pulse — живой монитор рыночной активности\n")

while True:
    pulse = {}
    for symbol in symbols[:50]:  # ограничим первые 50 пар
        try:
            ticker = exchange.fetch_ticker(symbol)
            price = ticker['last']
            vol = ticker['baseVolume']

            price_data[symbol].append(price)
            volume_data[symbol].append(vol)

            if len(price_data[symbol]) > 3:
                dp = abs(price_data[symbol][-1] - price_data[symbol][-2]) / price_data[symbol][-2]
                dv = abs(volume_data[symbol][-1] - volume_data[symbol][-2]) / (volume_data[symbol][-2] + 1e-9)
                pulse[symbol] = dp * dv

                price_data[symbol] = price_data[symbol][-3:]
                volume_data[symbol] = volume_data[symbol][-3:]
        except Exception:
            continue

    # Топ 5 по пульсу
    if pulse:
        top = sorted(pulse.items(), key=lambda x: x[1], reverse=True)[:5]
        print("\n🔥 Топ активных пар:")
        for sym, score in top:
            print(f"{sym}: VPI={score:.6f}")
    time.sleep(3)

G = \frac{\Delta(\text{объём})}{\Delta t}

import ccxt
import time

exchange = ccxt.binance({'enableRateLimit': True})
symbol = 'BTC/USDT'

def calc_gradient(prev_bids, prev_asks, bids, asks):
    bid_vol_prev = sum(v for _, v in prev_bids[:10])
    ask_vol_prev = sum(v for _, v in prev_asks[:10])
    bid_vol = sum(v for _, v in bids[:10])
    ask_vol = sum(v for _, v in asks[:10])
    return (bid_vol - bid_vol_prev), (ask_vol - ask_vol_prev)

prev = exchange.fetch_order_book(symbol)
time.sleep(1)

print(f"Order Flow Gradient tracking {symbol}...\n")

while True:
    ob = exchange.fetch_order_book(symbol)
    bid_grad, ask_grad = calc_gradient(prev['bids'], prev['asks'], ob['bids'], ob['asks'])
    diff = bid_grad - ask_grad

    if diff > 0:
        print(f"🟢 Покупатели усиливаются: градиент {diff:.4f}")
    elif diff < 0:
        print(f"🔴 Продавцы усиливаются: градиент {diff:.4f}")
    else:
        print(f"⚪ Баланс сил")

    prev = ob
    time.sleep(1)

import ccxt
import time
import numpy as np

exchange = ccxt.binance({'enableRateLimit': True})
symbol = 'BTC/USDT'

latencies = []

print("⚙️ Latency Pulse Monitor запущен...\n")

while True:
    start = time.time()
    try:
        exchange.fetch_ticker(symbol)
    except Exception:
        continue
    latency = time.time() - start
    latencies.append(latency)

    if len(latencies) > 30:
        latencies.pop(0)

        mean_lat = np.mean(latencies)
        std_lat = np.std(latencies)
        last_lat = latencies[-1]

        if last_lat > mean_lat + 2 * std_lat:
            print(f"⚠️ Всплеск сетевой задержки ({last_lat:.3f}s) — возможен всплеск активности на рынке!")
        else:
            print(f"✅ Нормальный пульс: {last_lat:.3f}s (среднее {mean_lat:.3f}s)")
    time.sleep(2)

import ccxt
import time
import numpy as np

exchange = ccxt.binance({'enableRateLimit': True})
symbol = 'BTC/USDT'
prices = []

print(f"🚀 Запуск стратегии Echo Reversal для {symbol}")

while True:
    ticker = exchange.fetch_ticker(symbol)
    price = ticker['last']
    prices.append(price)

    if len(prices) > 6:
        speeds = np.diff(prices[-4:])  # скорость
        accels = np.diff(speeds)       # ускорение

        speed = np.mean(speeds[-2:])
        accel = np.mean(accels)

        if speed > 0 and accel < 0:
            print(f"[SHORT] Импульс затухает — потенциальный разворот вниз при {price}")
        elif speed < 0 and accel > 0:
            print(f"[LONG] Импульс выдыхается — потенциальный разворот вверх при {price}")

        prices = prices[-6:]

    time.sleep(2)

import ccxt
import time
import numpy as np

exchange = ccxt.binance({'enableRateLimit': True})
symbol = 'BTC/USDT'

print(f"🧭 Market Friction Meter активен для {symbol}")

prev_mid = None
prev_bid_vol = None
prev_ask_vol = None

while True:
    ob = exchange.fetch_order_book(symbol)
    bids = np.array(ob['bids'][:20])
    asks = np.array(ob['asks'][:20])

    bid_vol = bids[:,1].sum()
    ask_vol = asks[:,1].sum()
    mid_price = (bids[0,0] + asks[0,0]) / 2

    if prev_mid is not None:
        delta_p = abs(mid_price - prev_mid)
        delta_v = abs((bid_vol - prev_bid_vol) + (ask_vol - prev_ask_vol))
        FI = delta_p / (delta_v + 1e-9)

        if FI < 1e-5:
            print(f"⚠️ Высокое рыночное трение ({FI:.2e}) — готовится резкий пробой")
        elif FI > 1e-3:
            print(f"💨 Низкое трение ({FI:.2e}) — цена движется свободно")
        else:
            print(f"ℹ️ Среднее трение ({FI:.2e}) — рынок стабилен")

    prev_mid = mid_price
    prev_bid_vol = bid_vol
    prev_ask_vol = ask_vol
    time.sleep(2)

import ccxt
import time
import numpy as np

exchange = ccxt.binance({'enableRateLimit': True})
symbol = 'BTC/USDT'

print(f"🚀 Стратегия Order Exhaustion Trap активна для {symbol}")

history = []

def pressure(orderbook, side="bids", depth=5):
    levels = orderbook[side][:depth]
    return sum(v for _, v in levels)

while True:
    ob = exchange.fetch_order_book(symbol)
    ticker = exchange.fetch_ticker(symbol)
    price = ticker['last']

    bp = pressure(ob, "bids")
    ap = pressure(ob, "asks")

    history.append((time.time(), price, bp, ap))
    if len(history) > 10:
        history = history[-10:]

        prices = [h[1] for h in history]
        bids = [h[2] for h in history]
        asks = [h[3] for h in history]

        price_slope = np.polyfit(range(len(prices)), prices, 1)[0]
        bid_slope = np.polyfit(range(len(bids)), bids, 1)[0]
        ask_slope = np.polyfit(range(len(asks)), asks, 1)[0]

        # логика: цена растёт, но давление покупателей падает
        if price_slope > 0 and bid_slope < 0:
            print(f"[SHORT] Цена ↑, покупатели выдыхаются ({price:.2f})")

        # цена падает, но давление продавцов падает
        elif price_slope < 0 and ask_slope < 0:
            print(f"[LONG] Цена ↓, продавцы выдыхаются ({price:.2f})")

    time.sleep(2)

import ccxt
import time
from datetime import datetime
import numpy as np

exchange = ccxt.binance({'enableRateLimit': True})
symbol = 'BTC/USDT'

DEPTH_LEVELS = 10
PRESSURE_THR = 0.3
REFRESH_SEC = 2

def now():
    return datetime.utcnow().strftime("%H:%M:%S")

def get_pressure(symbol):
    order_book = exchange.fetch_order_book(symbol, limit=DEPTH_LEVELS)
    bids = np.array(order_book['bids'])
    asks = np.array(order_book['asks'])
    bid_vol = bids[:,1].sum()
    ask_vol = asks[:,1].sum()
    pressure = (bid_vol - ask_vol) / (bid_vol + ask_vol)
    mid = (bids[0,0] + asks[0,0]) / 2
    return pressure, mid

last_price = None
last_pressure = None

print(f"{now()} ▶ Начало наблюдения за {symbol}")

while True:
    try:
        pressure, price = get_pressure(symbol)

        if last_price:
            delta_p = price - last_price
            delta_press = pressure - last_pressure if last_pressure else 0

            msg = f"{now()} price={price:.2f} pressure={pressure:+.2f}"
            if pressure > PRESSURE_THR and abs(delta_p) < price * 0.0005:
                print(msg + " ⚡ LONG setup (рост давления без движения цены)")
            elif pressure < -PRESSURE_THR and abs(delta_p) < price * 0.0005:
                print(msg + " ⚡ SHORT setup (продавцы давят, цена застыла)")
            else:
                print(msg)

        last_price = price
        last_pressure = pressure
        time.sleep(REFRESH_SEC)
    except Exception as e:
        print("Ошибка:", e)
        time.sleep(REFRESH_SEC)

AABbSMAaaBBM...

import asyncio
import json
import statistics
import time
import websockets
from collections import deque

SYMBOL = "btcusdt"
WS_URL = f"wss://stream.binance.com:9443/ws/{SYMBOL}@trade"
WINDOW = 200
SMOOTH = 0.9  # EMA smoothing for tension

async def market_stress_radar():
    print(f"🧭 Market Stress Radar — {SYMBOL}")
    last_time = None
    intervals = deque(maxlen=WINDOW)
    tension_ema = 0

    async with websockets.connect(WS_URL) as ws:
        while True:
            msg = json.loads(await ws.recv())
            t = msg["T"] / 1000
            if last_time:
                dt = t - last_time
                if dt > 0:
                    intervals.append(dt)

                    if len(intervals) > 10:
                        vol = statistics.stdev(intervals)
                        tension = 1 / (vol + 1e-6)
                        if tension_ema == 0:
                            tension_ema = tension
                        else:
                            tension_ema = SMOOTH * tension_ema + (1 - SMOOTH) * tension

                        level = ""
                        if tension_ema > 80:
                            level = "🔥 HIGH STRESS"
                        elif tension_ema > 50:
                            level = "⚠️ MEDIUM"
                        else:
                            level = "🟢 Calm"

                        print(f"[{time.strftime('%H:%M:%S')}] tension={tension_ema:6.2f} | {level}")

            last_time = t

if __name__ == "__main__":
    asyncio.run(market_stress_radar())

import asyncio
import json
import time
import websockets

SYMBOL = "btcusdt"
WS_URL = f"wss://stream.binance.com:9443/ws/{SYMBOL}@depth20@100ms"

VANISH_THRESHOLD = 0.6  # 60%
CHECK_INTERVAL = 3.0

class ShadowDepthBreak:
    def __init__(self):
        self.last_snapshot = None
        self.last_time = time.time()

    def detect_vanish(self, new_depth):
        if self.last_snapshot is None:
            self.last_snapshot = new_depth
            return None

        prev_bids = {p: v for p, v in self.last_snapshot['bids']}
        prev_asks = {p: v for p, v in self.last_snapshot['asks']}

        new_bids = {p: v for p, v in new_depth['bids']}
        new_asks = {p: v for p, v in new_depth['asks']}

        def total(vols): return sum(vols.values())

        vanish_bid = 0.0
        vanish_ask = 0.0

        for p, v in prev_bids.items():
            if p in new_bids:
                if v > 0:
                    vanish_bid += max(0, v - new_bids[p])
            else:
                vanish_bid += v

        for p, v in prev_asks.items():
            if p in new_asks:
                if v > 0:
                    vanish_ask += max(0, v - new_asks[p])
            else:
                vanish_ask += v

        bid_loss = vanish_bid / (total(prev_bids) + 1e-9)
        ask_loss = vanish_ask / (total(prev_asks) + 1e-9)

        signal = None
        if bid_loss > VANISH_THRESHOLD:
            signal = "🚨 SHORT — bids vanished {:.0%}".format(bid_loss)
        elif ask_loss > VANISH_THRESHOLD:
            signal = "🚨 LONG — asks vanished {:.0%}".format(ask_loss)

        self.last_snapshot = new_depth
        return signal

async def main():
    print(f"🧠 Shadow Depth Break started for {SYMBOL}")
    sdb = ShadowDepthBreak()
    async with websockets.connect(WS_URL) as ws:
        while True:
            msg = json.loads(await ws.recv())
            now = time.time()
            if now - sdb.last_time >= CHECK_INTERVAL:
                sdb.last_time = now
                signal = sdb.detect_vanish(msg)
                if signal:
                    print(f"[{time.strftime('%H:%M:%S')}] {signal}")

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import json
import websockets
import statistics
import time

url = "wss://stream.binance.com:9443/ws/btcusdt@trade"
depth_url = "wss://stream.binance.com:9443/ws/btcusdt@depth20@100ms"

trade_volumes = []
liquidity_levels = []
prev_time = time.time()

async def trade_listener():
    global trade_volumes
    async with websockets.connect(url) as ws:
        async for msg in ws:
            data = json.loads(msg)
            trade_volumes.append(float(data["q"]))
            if len(trade_volumes) > 100:
                trade_volumes.pop(0)

async def depth_listener():
    global liquidity_levels, prev_time
    async with websockets.connect(depth_url) as ws:
        async for msg in ws:
            data = json.loads(msg)
            bids = sum(float(b[1]) for b in data["bids"][:5])
            asks = sum(float(a[1]) for a in data["asks"][:5])
            total_liq = bids + asks
            liquidity_levels.append(total_liq)
            if len(liquidity_levels) > 50:
                liquidity_levels.pop(0)

            if len(trade_volumes) > 10:
                avg_vol = statistics.mean(trade_volumes)
                avg_liq = statistics.mean(liquidity_levels)
                cur_vol = trade_volumes[-1]
                cur_liq = liquidity_levels[-1]

                delta_vol = (cur_vol - avg_vol) / (avg_vol + 1e-9)
                delta_liq = (cur_liq - avg_liq) / (avg_liq + 1e-9)

                if delta_vol > 0.5 and delta_liq < -0.3:
                    print(f"⚡ UP FRACTURE — volume +{delta_vol:.1f}, liquidity {delta_liq:.1f}")
                elif delta_vol > 0.5 and delta_liq > 0.3:
                    print(f"⚠️ FAKE FRACTURE — too much liquidity added")
                elif delta_vol < -0.3 and delta_liq < -0.3:
                    print(f"🔻 DOWN FRACTURE — structure collapsing")

async def main():
    await asyncio.gather(trade_listener(), depth_listener())

asyncio.run(main())

imbalance = \frac{bid\_vol - ask\_vol}{bid\_vol + ask\_vol}

import asyncio
import json
import time
import statistics
import websockets
import ccxt

symbol = "BTC/USDT"
ws_url = "wss://stream.binance.com:9443/ws/btcusdt@depth20@100ms"
exchange = ccxt.binance()

async def order_flow_tracer():
    print(f"⚔️ Order Flow Tracer started for {symbol}")
    prev_imbalance = None
    prev_time = time.time()

    async with websockets.connect(ws_url) as ws:
        while True:
            msg = json.loads(await ws.recv())
            bids = msg["bids"][:5]
            asks = msg["asks"][:5]

            bid_vol = sum(float(b[1]) for b in bids)
            ask_vol = sum(float(a[1]) for a in asks)
            imbalance = (bid_vol - ask_vol) / (bid_vol + ask_vol + 1e-9)

            now = time.time()
            dt = now - prev_time
            if prev_imbalance is not None and dt > 0:
                delta = imbalance - prev_imbalance
                speed = delta / dt

                if abs(speed) > 1.5:
                    side = "LONG" if speed > 0 else "SHORT"
                    print(f"[{time.strftime('%H:%M:%S')}] ⚡ {side} signal | imbalance Δ={delta:.2f}")

            prev_imbalance = imbalance
            prev_time = now

if __name__ == "__main__":
    asyncio.run(order_flow_tracer())

import asyncio
import json
import websockets
import statistics
import time

SYMBOL = "btcusdt"
URL = f"wss://stream.binance.com:9443/ws/{SYMBOL}@kline_1m"

prices = []
volumes = []
window = 3  # минут

async def listen():
    async with websockets.connect(URL) as ws:
        async for msg in ws:
            data = json.loads(msg)
            k = data["k"]
            if not k["x"]:  # свеча не закрыта
                continue
            close = float(k["c"])
            vol = float(k["v"])
            prices.append(close)
            volumes.append(vol)
            if len(prices) > window:
                prices.pop(0)
                volumes.pop(0)

            rng = (max(prices) - min(prices)) / statistics.mean(prices)
            vol_mean = statistics.mean(volumes)

            if rng < 0.002 and vol_mean > 0.7 * max(volumes):
                print(f"🕰 TIME POCKET detected at {close:.2f}")
            elif rng > 0.003:
                print(f"⚡ BREAKOUT from pocket → {close:.2f}")

asyncio.run(listen())

import asyncio
import json
import numpy as np
import matplotlib.pyplot as plt
import websockets

SYMBOL = "btcusdt"
URL = f"wss://stream.binance.com:9443/ws/{SYMBOL}@depth20@100ms"

heatmap = np.zeros(40)  # 20 уровней bid + 20 уровней ask

async def order_heat_echo():
    async with websockets.connect(URL) as ws:
        while True:
            data = json.loads(await ws.recv())
            bids = data["bids"]
            asks = data["asks"]

            # Расчёт изменения плотности ордеров
            for i, b in enumerate(bids[:20]):
                heatmap[i] = float(b[1])
            for i, a in enumerate(asks[:20]):
                heatmap[20 + i] = float(a[1]) * -1  # продавцы — отрицательные значения

            plt.clf()
            plt.bar(range(len(heatmap)), heatmap, color=["red" if v < 0 else "blue" for v in heatmap])
            plt.pause(0.01)

asyncio.run(order_heat_echo())