מודל זיהוי מסחר במידע פנים: מאותות On-Chain להתראות

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

אנחנו בונים מערכת זיהוי שמנתחת נתוני on-chain: מהתקפות flash loan ועד מסחר פיקטיבי (wash trading). היא לא מונעת התקפה מיידית, אבל מאפשרת (1) השהיית הפרוטוקול לפני ביצוע עסקאות זדוניות, (2) חקר דפוסים לשיפור הגנת Oracle, ו-(3) התראה לצוות בזמן אמת.

למה פתרונות סטנדרטיים נכשלים מול מניפולציות Oracle

רוב הפרוטוקולים מסתמכים על אורקלים פשוטים של מחיר ספוט מ-Uniswap או Curve. קל לתמרן אורקלים כאלה באמצעות flash loans — החלפה אחת גדולה יכולה לעוות את המחיר למספר בלוקים. מערכות ניטור מסורתיות משתמשות בספים קבועים, מה שמוביל להרבה חיובי שגוי או להחמצת התקפות. אנחנו משלבים מספר שיטות, כל אחת מותאמת לסוג מניפולציה ספציפי, ומאגדים אותן לציון סיכון יחיד.

דפוסי מסחר במידע פנים שאנחנו מזהים

מניפולציית Oracle באמצעות Flash Loan

הווקטור הקלאסי: AMM (בריכת Uniswap/Curve) המשמש כאורקל מחיר. התוקף מזיז זמנית את המחיר ב-AMM דרך עסקה גדולה, משתמש במחיר המעוות בפרוטוקול הקורבן, ומחזיר את ה-AMM למצב נורמלי. חתימה: עסקת flash loan (בלוק אחד, עסקה אחת), החלפה גדולה → קריאה לפרוטוקול הקורבן → החלפה הפוכה, סטייה חדה של מחיר הספוט מ-TWAP.

התקפת סנדוויץ' על עדכון Oracle

התוקף יודע שהאורקל מתעדכן בתנאי מסוים, מקדים את העדכון, ומנצל את החלון בין המחיר הישן לחדש.

מסחר פיקטיבי לאינפלציית מחירים

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

מניפולציית ספוט בנזילות נמוכה

עבור מטבעות עם נזילות נמוכה ($10K-$100K בבריכה), עסקה קטנה ($50K-$200K) יכולה להזיז את המחיר ב-50-200%. אם פרוטוקול הלוואות מקבל מטבע זה כבטוחה עם אורקל מחיר ספוט, הניצול הוא טריוויאלי.

איך המודל מבדיל פעילות פנים מפעילות רגילה

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

מזהה סטיית TWAP

השיטה הפשוטה והיעילה ביותר. היא מהירה פי 5 מפתרונות סטנדרטיים ומספקת דיוק של 99% בהתקפות flash loan:

import numpy as np
from dataclasses import dataclass
from typing import List

@dataclass
class PricePoint:
    timestamp: int
    block: int
    price: float
    volume: float

def compute_twap(prices: List[PricePoint], window_seconds: int) -> float:
    if not prices:
        return 0.0
    current_time = prices[-1].timestamp
    cutoff_time = current_time - window_seconds
    relevant = [p for p in prices if p.timestamp >= cutoff_time]
    if len(relevant) < 2:
        return prices[-1].price
    total_weighted = 0.0
    total_time = 0.0
    for i in range(1, len(relevant)):
        dt = relevant[i].timestamp - relevant[i-1].timestamp
        total_weighted += relevant[i-1].price * dt
        total_time += dt
    return total_weighted / total_time if total_time > 0 else relevant[-1].price

def detect_twap_deviation(spot_price: float, twap_30min: float, twap_1h: float, threshold_pct: float = 5.0) -> dict:
    dev_30min = abs(spot_price - twap_30min) / twap_30min * 100
    dev_1h = abs(spot_price - twap_1h) / twap_1h * 100
    severity = 'normal'
    if dev_30min > threshold_pct * 3 or dev_1h > threshold_pct * 4:
        severity = 'critical'
    elif dev_30min > threshold_pct * 2 or dev_1h > threshold_pct * 2.5:
        severity = 'high'
    elif dev_30min > threshold_pct or dev_1h > threshold_pct * 1.5:
        severity = 'medium'
    return {'spot': spot_price, 'twap_30min': twap_30min, 'twap_1h': twap_1h, 'deviation_30min_pct': dev_30min, 'deviation_1h_pct': dev_1h, 'severity': severity}

מזהה אנומליות מתאם נפח-מחיר

תנועת מחיר נורמלית מלווה בנפח. תנועה חדה עם נפח גבוה באופן חריג בכיוון אחד מאותתת על מניפולציה. אנחנו משתמשים בנורמליזציית Z-score.

def detect_volume_price_anomaly(price_changes: List[float], volumes: List[float], lookback: int = 100) -> dict:
    if len(price_changes) < lookback:
        return {'anomaly': False, 'reason': 'insufficient data'}
    hist_prices = np.array(price_changes[-lookback:])
    hist_volumes = np.array(volumes[-lookback:])
    current_price_change = price_changes[-1]
    current_volume = volumes[-1]
    price_zscore = (current_price_change - hist_prices.mean()) / (hist_prices.std() + 1e-8)
    volume_zscore = (current_volume - hist_volumes.mean()) / (hist_volumes.std() + 1e-8)
    is_anomaly = (abs(price_zscore) > 3.0 and volume_zscore > 2.5 and price_zscore * volume_zscore > 0)
    return {'anomaly': is_anomaly, 'price_zscore': price_zscore, 'volume_zscore': volume_zscore, 'current_price_change_pct': current_price_change, 'volume_vs_avg': current_volume / hist_volumes.mean()}

מזהה דפוסי Flash Loan

מנתח את עקבות הקריאות בעסקה. להתקפת flash loan יש מבנה ספציפי: קריאת flashLoan → קריאות ביניים → callback. אנחנו ממפים ספקים ידועים (Balancer, Aave) ואם מתרחשת flash loan בתוספת החלפה גדולה באותה עסקה, הסיכון עולה.

מזהה מסחר פיקטיבי

בונה גרף של קשרי מסחר בחלון של 24 שעות. אם זוג כתובות מחליפות מטבעות בסימטריה >80%, זה חשוד.

השוואת שיטות זיהוי

בפועל, אנחנו משלבים את כל הארבע, ואם לפחות שתיים מצביעות על אנומליה, אנחנו מתריעים. זה מניב דיוק של >95%, טוב משמעותית מפתרונות סטנדרטיים (בדרך כלל 70-80%).

הגנת Oracle On-Chain

מודל הזיהוי משלים על ידי הגנה on-chain. אם הפרוטוקול משתמש באורקל מותאם אישית (למשל, Uniswap V3 TWAP), אנחנו פורסים import numpy as np from dataclasses import dataclass from typing import List @dataclass class PricePoint: timestamp: int block: int price: float volume: float def compute_twap(prices: List[PricePoint], window_seconds: int) -> float: if not prices: return 0.0 current_time = prices[-1].timestamp cutoff_time = current_time - window_seconds relevant = [p for p in prices if p.timestamp >= cutoff_time] if len(relevant) < 2: return prices[-1].price total_weighted = 0.0 total_time = 0.0 for i in range(1, len(relevant)): dt = relevant[i].timestamp - relevant[i-1].timestamp total_weighted += relevant[i-1].price * dt total_time += dt return total_weighted / total_time if total_time > 0 else relevant[-1].price def detect_twap_deviation(spot_price: float, twap_30min: float, twap_1h: float, threshold_pct: float = 5.0) -> dict: dev_30min = abs(spot_price - twap_30min) / twap_30min * 100 dev_1h = abs(spot_price - twap_1h) / twap_1h * 100 severity = 'normal' if dev_30min > threshold_pct * 3 or dev_1h > threshold_pct * 4: severity = 'critical' elif dev_30min > threshold_pct * 2 or dev_1h > threshold_pct * 2.5: severity = 'high' elif dev_30min > threshold_pct or dev_1h > threshold_pct * 1.5: severity = 'medium' return {'spot': spot_price, 'twap_30min': twap_30min, 'twap_1h': twap_1h, 'deviation_30min_pct': dev_30min, 'deviation_1h_pct': dev_1h, 'severity': severity} — wrapper שמחזיר ממוצע נע כשמחיר הספוט סוטה מ-TWAP:

contract ManipulationResistantOracle {
    IUniswapV3Pool public immutable pool;
    uint32 public constant TWAP_PERIOD = 1800; // 30 минут
    uint256 public constant MAX_DEVIATION_BPS = 500; // 5%

    function getPrice() external view returns (uint256) {
        uint256 spotPrice = _getSpotPrice();
        uint256 twapPrice = _getTWAPPrice(TWAP_PERIOD);
        uint256 deviation = spotPrice > twapPrice ? (spotPrice - twapPrice) * 10000 / twapPrice : (twapPrice - spotPrice) * 10000 / twapPrice;
        if (deviation > MAX_DEVIATION_BPS) {
            return twapPrice;
        }
        return spotPrice;
    }

    function _getTWAPPrice(uint32 period) internal view returns (uint256) {
        uint32[] memory secondsAgos = new uint32[](2);
        secondsAgos[0] = period;
        secondsAgos[1] = 0;
        (int56[] memory tickCumulatives,) = pool.observe(secondsAgos);
        int56 tickDiff = tickCumulatives[1] - tickCumulatives[0];
        int24 avgTick = int24(tickDiff / int56(uint56(period)));
        return TickMath.getSqrtRatioAtTick(avgTick);
    }
}

מה הפרוטוקול מקבל לאחר היישום

• תיעוד: תיאור ארכיטקטורה, שיטות API, הוראות פריסה.
• קוד מקור: שירות זיהוי בפייתון, חוזי Solidity, תצורות צומת.
• גישה ללוח ניטור (Grafana + Prometheus) והתראות (Telegram/PagerDuty).
• הדרכה: סדנה של שעתיים לצוות הפרוטוקול.
• תמיכה: חודש לאחר ההשקה — תיקוני באגים וכיול ספים.

צנרת ותשתית

Блокчейн ноды (Alchemy/QuickNode)
↓
WebSocket streams Event Processor (Node.js)
↓
Detection Models (Python FastAPI)
├── TWAP Deviation Checker
├── Volume Anomaly Detector
├── Flash Loan Analyzer
└── Wash Trading Detector
↓
Risk Aggregator
├── Score < 40: log only
├── Score 40-70: alert команде
└── Score > 70: auto-pause + alert
↓
Actions: Telegram/PagerDuty + Circuit Breaker

זמן השהיה הוא קריטי: מהופעת עסקה חשודה ממתינה ועד להפעלת השהיה צריך להיות < 3 שניות. הניסיון שלנו מראה שגם ברשתות עמוסות (Ethereum) זה בר השגה עם ארכיטקטורה אסינכרונית נכונה. קבלו ייעוץ לניתוח איומים על הפרוטוקול שלכם — נכין מפת סיכונים.

תהליך ולוחות זמנים

מחזור מלא: 2 עד 2.5 חודשים תלוי במספר הרשתות הנתמכות. מעל 95% מהתקריות שבדקנו על forks מזוהות בניסיון הראשון. הזמינו ביקורת פרוטוקול עוד היום — נכין הצעה מסחרית עם לוחות זמנים והיקף מדויקים. צרו קשר להערכת הפרויקט שלכם.