מערכת התראות לסוחרים: מחיר, נפח, פירוקים

בעת מסחר ב-Binance Futures, אתה עלול לפספס פירוק פתאומי של שחקן גדול אם לא מוגדרות התראות. עיכוב של כמה שניות הופך עסקה רווחית להפסד. פעם אחת, לקוח איבד סכום גדול כי REST API לא עדכן את המחיר בזמן — הפירוק התרחש תוך 200 אלפיות השנייה, בעוד שהסקר הגיע 3 שניות מאוחר יותר. אנו מפתחים מערכות התראה שפותרות בעיה זו: ניטור מחיר, נפח ופירוקים בזמן אמת עם שליחה ל-Telegram, דוא"ל או webhook. לצוות שלנו יש ניסיון של למעלה מ-7 שנים בפיתוח blockchain, יישמנו למעלה מ-20 פרויקטים במסחר קריפטו, תוך הבטחת אמינות גבוהה וזמן השהיה של פחות מ-50 אלפיות השנייה. אנו מבטיחים זמינות של 99.9% ותקופת תמיכה של 3 חודשים. המערכת שלנו התריעה על למעלה מ-1,200 פירוקים העולים על $1M בשנה האחרונה.

ללא מערכת התראה, סוחר צריך לפקח כל הזמן על גרפים או להסתמך על בקשות REST API איטיות. הפתרון שלנו הופך את הניטור לאוטומטי ומספק התראות דרך כל ערוץ. הוא מכסה שלוש קטגוריות אירועים מרכזיות: התראות מחיר, חריגות נפח ופירוקים.

בעיות שמערכת ההתראה פותרת

הבעיה המרכזית היא השהיית נתונים. בעת שימוש ב-REST API, עיכובים יכולים להגיע לכמה שניות, מה שקריטי למסחר בתדירות גבוהה. אנו משתמשים ב-חיבורי WebSocket, מה שמבטיח זמן השהיה של פחות מ-50 אלפיות השנייה — מהיר פי 100 מסקר API. הבעיה השנייה היא התראות שווא. המנוע שלנו מסנן עד 90% מאירועי הרעש באמצעות ספים הניתנים להגדרה ואלגוריתמי החלקה, כמו חלון נפח נע. השלישית היא מורכבות התאמה אישית. אנו מספקים מערכת כללים גמישה עם תמיכה בתנאים המשלבים מחיר, נפח ופירוקים, וכן יכולת להגדיר תנאים מורכבים דרך API. פרויקט טיפוסי חוסך $2,000 בחודש בעלויות שרת ומפחית התראות שווא ב-90%.

WebSocket מול REST API: השוואת מהירות

REST API דורש סקר קבוע, מה שיוצר עומס שרת מופרז וזמן השהיה של 1-5 שניות. WebSocket, לעומת זאת, משתמש במודל push: השרת שולח נתונים רק בשינויים. זה מפחית את העומס פי 10 ומבטיח זמן השהיה של פחות מ-50 אלפיות השנייה. עבור סוחר, זה אומר שההתראה מגיעה לפני שהמחיר פוגע ברמת stop-loss שנייה. חיסכון בעלויות תשתית — עד 80% בהשוואה ל-REST API.

כיצד בנויה מערכת ההתראה?

הארכיטקטורה מבוססת על מיקרוסרביסים ב-Python (asyncio, Redis, PostgreSQL). כל סוג התראה מיושם כמודול נפרד, מה שמפשט את קנה המידה. להלן דוגמה למודל כללים ומנוע.

class AlertRule(BaseModel):
    id: str
    user_id: str
    type: str  # 'price_above', 'price_below', 'volume_spike', 'liquidation'
    symbol: str
    exchange: str
    # Параметры в зависимости от типа
    price_threshold: Optional[Decimal]
    volume_multiplier: Optional[float]  # N × avg volume
    liquidation_usd: Optional[float]  # Доставка
    channels: list[str]  # ['telegram', 'email', 'push', 'webhook']
    webhook_url: Optional[str]
    # Поведение
    one_time: bool = True  # деактивировать после срабатывания
    cooldown_minutes: int = 60  # минимум между повторными срабатываниями
    last_triggered: Optional[datetime] = None
    is_active: bool = True

class AlertEngine:
    def __init__(self, rule_repo, notifier):
        self.rules = {}  # symbol → list[AlertRule]
        self.rule_repo = rule_repo
        self.notifier = notifier

    async def on_ticker_update(self, ticker: NormalizedTicker):
        rules = self.rules.get(f"{ticker.exchange}:{ticker.symbol}", [])
        for rule in rules:
            if not rule.is_active:
                continue
            if self.is_in_cooldown(rule):
                continue
            if await self.evaluate_rule(rule, ticker):
                await self.trigger_alert(rule, ticker)

    async def evaluate_rule(self, rule: AlertRule, ticker: NormalizedTicker) -> bool:
        if rule.type == 'price_above':
            return ticker.last >= rule.price_threshold
        elif rule.type == 'price_below':
            return ticker.last <= rule.price_threshold
        elif rule.type == 'price_change_pct':
            change = await self.compute_price_change(rule.symbol, rule.period_minutes)
            return abs(change) >= rule.change_pct_threshold
        return False

    async def trigger_alert(self, rule: AlertRule, ticker: NormalizedTicker):
        message = self.format_alert_message(rule, ticker)
        for channel in rule.channels:
            await self.notifier.send(channel, rule.user_id, message)
        rule.last_triggered = datetime.utcnow()
        if rule.one_time:
            rule.is_active = False
        await self.rule_repo.save(rule)

    def is_in_cooldown(self, rule: AlertRule) -> bool:
        if not rule.last_triggered:
            return False
        elapsed = (datetime.utcnow() - rule.last_triggered).total_seconds() / 60
        return elapsed < rule.cooldown_minutes
"}

כדי להוסיף התראת מחיר עבור BTC/USDT ב-Binance עם סף של $50,000 ושליחה ל-Telegram, שלח POST /alerts עם גוף JSON: class AlertRule(BaseModel): id: str user_id: str type: str # 'price_above', 'price_below', 'volume_spike', 'liquidation' symbol: str exchange: str # Параметры в зависимости от типа price_threshold: Optional[Decimal] volume_multiplier: Optional[float] # N × avg volume liquidation_usd: Optional[float] # Доставка channels: list[str] # ['telegram', 'email', 'push', 'webhook'] webhook_url: Optional[str] # Поведение one_time: bool = True # деактивировать после срабатывания cooldown_minutes: int = 60 # минимум между повторными срабатываниями last_triggered: Optional[datetime] = None is_active: bool = True . ציין את מזהה הצ'אט של Telegram בהגדרות — הניטור יתחיל תוך 5 שניות. זהו תהליך הגדרה טיפוסי שלב אחר שלב למשתמשים חדשים.

מקרה בוחן: הגדרת התראת פירוק

לקוח אחד — חברת מסחר prop — ביקש התראה על פירוקים גדולים ב-Bybit. פרסנו את מודול class AlertEngine: def __init__(self, rule_repo, notifier): self.rules = {} # symbol → list[AlertRule] self.rule_repo = rule_repo self.notifier = notifier async def on_ticker_update(self, ticker: NormalizedTicker): rules = self.rules.get(f"{ticker.exchange}:{ticker.symbol}", []) for rule in rules: if not rule.is_active: continue if self.is_in_cooldown(rule): continue if await self.evaluate_rule(rule, ticker): await self.trigger_alert(rule, ticker) async def evaluate_rule(self, rule: AlertRule, ticker: NormalizedTicker) -> bool: if rule.type == 'price_above': return ticker.last >= rule.price_threshold elif rule.type == 'price_below': return ticker.last <= rule.price_threshold elif rule.type == 'price_change_pct': change = await self.compute_price_change(rule.symbol, rule.period_minutes) return abs(change) >= rule.change_pct_threshold return False async def trigger_alert(self, rule: AlertRule, ticker: NormalizedTicker): message = self.format_alert_message(rule, ticker) for channel in rule.channels: await self.notifier.send(channel, rule.user_id, message) rule.last_triggered = datetime.utcnow() if rule.one_time: rule.is_active = False await self.rule_repo.save(rule) def is_in_cooldown(self, rule: AlertRule) -> bool: if not rule.last_triggered: return False elapsed = (datetime.utcnow() - rule.last_triggered).total_seconds() / 60 return elapsed < rule.cooldown_minutes ביום אחד: התחברנו ל-Bybit WebSocket, הגדרנו את הסף ואת השליחה ל-Telegram ו-Slack. בשבוע הראשון, המערכת התריעה על כ-12 פירוקים גדולים, שסוחרים השתמשו בהם כדי להיכנס לעסקאות נגד מגמה. זמן השהיה מאירוע להתראה — 45 אלפיות השנייה. הלקוח השיג עלייה של 15% בעסקאות רווחיות וחסך $3,000 בעלויות ניטור ידני בחודש.

התראות נפח

לאיתור חריגות נפח, נעשה שימוש בחלון נע של 20 נרות. זה מסנן עליות קצרות טווח ומגיב רק לשינויים משמעותיים.

class VolumeAnomalyDetector:
    WINDOW_PERIODS = 20  # свечей для расчёта среднего

    async def check_volume_spike(self, symbol: str, current_volume: Decimal) -> float:
        """Возвращает множитель относительно среднего объёма"""
        recent_volumes = await self.candle_repo.get_recent_volumes(
            symbol, count=self.WINDOW_PERIODS
        )
        if len(recent_volumes) < 5:
            return 1.0
        avg_volume = sum(recent_volumes) / len(recent_volumes)
        if avg_volume == 0:
            return 1.0
        return float(current_volume / avg_volume)

התראות פירוק

נתוני פירוק מתקבלים מבורסות (זרם forceOrder של Binance, פירוק Bybit) או מאגרגטורים (Coinalyze, CoinGlass API):

class LiquidationMonitor:
    async def monitor_binance_liquidations(self):
        async with websockets.connect("wss://fstream.binance.com/ws/!forceOrder@arr") as ws:
            async for message in ws:
                data = json.loads(message)
                order = data["o"]
                liquidation = Liquidation(
                    symbol=order["s"],
                    side=order["S"],
                    quantity=Decimal(order["q"]),
                    price=Decimal(order["p"]),
                    usd_value=Decimal(order["q"]) * Decimal(order["p"]),
                    timestamp=data["T"],
                )
                await self.process_liquidation(liquidation)

    async def process_liquidation(self, liq: Liquidation):
        await self.redis.incrbyfloat(
            f"liq_total:{liq.symbol}:1m", float(liq.usd_value)
        )
        await self.redis.expire(f"liq_total:{liq.symbol}:1m", 60)
        if liq.usd_value >= 1_000_000:
            await self.alert_engine.fire_liquidation_alert(liq)

אינטגרציה עם מקורות נתונים חיצוניים

אנו מתחברים לכל בורסה דרך WebSocket. עבור Binance, אנו משתמשים ב-Binance WebSocket Streams. הנתונים מנורמלים לפורמט {"user_id": "user123", "type": "price_below", "symbol": "BTCUSDT", "exchange": "Binance", "price_threshold": 50000, "channels": ["telegram"], "one_time": true} אחיד, מה שמפשט הוספת מקורות חדשים.

שליחת Webhook

class WebhookDelivery:
    async def send(self, webhook_url: str, alert: AlertMessage):
        payload = {
            "type": alert.type,
            "symbol": alert.symbol,
            "message": alert.text,
            "timestamp": alert.timestamp.isoformat(),
            "data": alert.raw_data,
        }
        signature = hmac.new(
            alert.rule.webhook_secret.encode(),
            json.dumps(payload).encode(),
            hashlib.sha256
        ).hexdigest()
        async with httpx.AsyncClient() as client:
            await client.post(
                webhook_url,
                json=payload,
                headers={"X-Alert-Signature": f"sha256={signature}"},
                timeout=10.0,
            )

התראות Webhook מאפשרות שילוב המערכת עם בוטים חיצוניים, מערכות מסחר, CRM. Webhook יכול להפעיל פעולות אוטומטיות — לדוגמה, פתיחת הזמנה בהתראת מחיר.

השוואת מודלי שליחה

מודל ה-push מהיר פי 10 ויעיל יותר עם מספר גדול של כללים. הזמן פיתוח — קבל אב טיפוס תוך 3 ימים.

תהליך הפיתוח

ציר זמן כולל — בין 10 ל-17 ימים תלוי במורכבות.

מה כלול בעבודה

התוצרים הבאים כלולים בכל פרויקט:

• תיעוד ארכיטקטורה ו-API
• קוד מקור (Python, asyncio)
• הוראות התקנה ותפעול
• הדרכת משתמשים (עד 4 שעות)
• תמיכה למשך 3 חודשים
• זמן השהיה מובטח של פחות מ-50 אלפיות השנייה או החזר כספי

צור קשר לייעוץ חינם עם מהנדס. מלא את הטופס באתר שלנו או כתוב ל-Telegram — תוך 24 שעות נכין הצעה מסחרית עם צירי זמן ועלויות מדויקים למשימות שלך.