פיתוח מערכת Market Making לנזילות בבורסה

ללא נזילות, בורסה מתה: מרווח רחב, השפעת מחיר עמוקה, סוחרים שעוזבים למתחרים. שקלו משימה טיפוסית: בורסה משיקה זוג BTC/USDT, אבל המרווח הוא 50 נקודות בסיס בהיקף של $1000. סוחרים עוברים ל-Binance. הפתרון שלנו הוא לפרוס בוט עם מרווח דינמי של 10 נקודות בסיס ועומק של $50k. תוצאה: המרווח יורד ל-15 נקודות בסיס, ההיקף גדל פי 5. אנו מפתחים מערכות market making מוכנות לשימוש — מאסטרטגיה ועד ייצור. לצוות יש 10+ פרויקטים ב-DeFi וב-CeFi. פיתוח מערכת נזילות לבורסה (market making) דורש הבנה עמוקה של מבנה השוק וניהול סיכונים.

למה מרווח דינמי הוא קריטי לנזילות?

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

איך market making פותר את בעיית הנזילות?

מרווח דינמי מול סטטי — פיתוח מערכת נזילות

מרווח סטטי אינו מסתגל לתנודתיות ולאירועים. התוצאה היא או הפסד בתקופות תנודתיות גבוהות או אובדן תחרותיות. אנו משתמשים במרווח דינמי שמתרחב בתקופות תנודתיות גבוהה ולפני אירועים חשובים (FED, חציות).

ניהול סיכון מלאי

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

סיכון ביצוע בגידור

העיכוב בין עסקת לקוח לגידור ב-Binance (1-100 אלפיות השנייה) יוצר סיכון החלקה. אנו ממזערים אותו באמצעות API עם זמן השהיה נמוך ומיקום שרתים קרוב לבורסה.

איך בנויה ארכיטקטורת הבוט?

ארכיטקטורת בוט בסיסית

class MarketMaker:
    def __init__(self, symbol: str, config: MMConfig):
        self.symbol = symbol
        self.spread_bps = config.spread_bps
        self.order_size_base = config.order_size
        self.num_layers = config.num_layers
        self.layer_spacing_bps = config.layer_spacing

    async def compute_quotes(self, mid_price: float) -> list[Quote]:
        quotes = []
        inventory_skew = self.calculate_inventory_skew()
        for i in range(1, self.num_layers + 1):
            bid_offset_bps = self.spread_bps * i + inventory_skew
            ask_offset_bps = self.spread_bps * i - inventory_skew
            bid_price = mid_price * (1 - bid_offset_bps / 10000)
            ask_price = mid_price * (1 + ask_offset_bps / 10000)
            size = self.order_size_base / i
            quotes.append(Quote('buy', bid_price, size))
            quotes.append(Quote('sell', ask_price, size))
        return quotes

    def calculate_inventory_skew(self) -> float:
        target_inventory = 0
        current_inventory = self.get_current_inventory()
        inventory_deviation = current_inventory - target_inventory
        skew = inventory_deviation * self.inventory_skew_factor
        return max(-self.max_skew_bps, min(self.max_skew_bps, skew))

גידור

async def hedge_trade(self, trade: InternalTrade):
    hedge_side = 'buy' if trade.side == 'sell' else 'sell'
    await self.hedge_exchange.market_order(
        symbol=self.symbol,
        side=hedge_side,
        quantity=trade.quantity
    )

ניהול מלאי

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

def get_inventory_metrics(self) -> dict:
    current_pos = self.get_position_btc()
    pos_value_usd = current_pos * self.get_mid_price()
    return {
        "position_btc": current_pos,
        "position_usd": pos_value_usd,
        "max_inventory_usd": self.config.max_inventory_usd,
        "utilization": abs(pos_value_usd) / self.config.max_inventory_usd,
        "pnl_unrealized": self.calculate_unrealized_pnl(current_pos)
    }

מהו סיכון ביצוע ואיך למזער אותו?

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

איך מחושב מרווח דינמי?

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

def calculate_dynamic_spread(self) -> float:
    base_spread = self.config.base_spread_bps
    volatility = self.get_realized_volatility_1h()
    vol_multiplier = max(1.0, volatility / self.baseline_volatility)
    event_factor = 1.5 if self.is_event_window() else 1.0
    hedge_spread = self.get_hedge_exchange_spread()
    hedge_factor = max(1.0, hedge_spread / self.baseline_hedge_spread)
    return base_spread * vol_multiplier * event_factor * hedge_factor

תוכנית ספק נזילות

בורסה יכולה למשוך market makers חיצוניים באמצעות החזר עמלות. רמות סטנדרטיות:

עמלת Maker שלילית פירושה שהבורסה משלמת ל-market maker עבור כל פקודה שבוצעה. זהו נוהג סטנדרטי.

דרישות ביצועים

def check_mm_performance(self, mm_id: str, period_minutes: int = 60) -> MMScore:
    quotes = self.db.get_mm_quotes(mm_id, period_minutes)
    total_seconds = period_minutes * 60
    active_seconds = sum(q.duration for q in quotes if q.has_both_sides)
    uptime = active_seconds / total_seconds
    avg_spread = statistics.mean(q.spread_bps for q in quotes)
    avg_depth_usd = statistics.mean(q.total_depth_usd for q in quotes)
    return MMScore(
        uptime=uptime,
        avg_spread_bps=avg_spread,
        avg_depth_usd=avg_depth_usd
    )

נזילות AMM על השרשרת

עבור DEX, נזילות מסופקת באמצעות פוזיציות LP. השוואה:

עבור היקפים רציניים, market making בבורסה מרכזית יעיל יותר. AMM מתאים כנזילות גיבוי עבור מטבעות עם זנב ארוך.

תהליך עבודה

1. ניתוח נזילות ומתחרים
2. עיצוב אסטרטגיה תוך התחשבות בסיכון
3. פיתוח בוט ב-Python/Solidity + Foundry
4. בדיקות היסטוריות וסימולציה
5. פריסה לייצור וניטור

ציר זמן: משבועיים עד חודשיים בהתאם למורכבות. העלות מחושבת באופן אישי.

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

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

אנו מבטיחים איכות: מהנדסים מוסמכים, ניסיון עם למעלה מ-10 פרויקטים מצליחים. צרו קשר להערכת פרויקט. הזמינו פיתוח מערכת market making מוכנה לשימוש — קבלו ייעוץ לפרויקט שלכם.

ויקיפדיה: Market maker