שילוב ספק נזילות מלא-מחזור לבורסת המטבעות שלך

class ResilientLPManager:
    def __init__(self, providers: list, fallback_amm=None):
        self.providers = {p.name: p for p in providers}
        self.provider_health = {p.name: True for p in providers}
        self.fallback_amm = fallback_amm  # DEX как fallback

    async def get_quote_with_fallback(self, symbol, side, qty) -> LPQuote:
        for provider_name, provider in self.providers.items():
            if not self.provider_health[provider_name]:
                continue
            try:
                quote = await asyncio.wait_for(
                    provider.get_quote(symbol, side, qty),
                    timeout=2.0
                )
                return quote
            except (asyncio.TimeoutError, LPError) as e:
                logger.warning(f"LP {provider_name} failed: {e}")
                await self.mark_unhealthy(provider_name)
        if self.fallback_amm:
            return await self.fallback_amm.get_quote(symbol, side, qty)
        raise NoLiquidityAvailable("All LP providers failed")

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

אגרגציית נזילות ממספר ספקים

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

class LiquidityAggregator:
    def __init__(self, providers: list[BaseLPClient]):
        self.providers = providers
        self.quotes: dict[str, list[LPQuote]] = {}

    def on_quote_update(self, quote: LPQuote):
        symbol = quote.symbol
        if symbol not in self.quotes:
            self.quotes[symbol] = []
        self.quotes[symbol] = [ q for q in self.quotes[symbol] if q.provider != quote.provider ]
        self.quotes[symbol].append(quote)

    def get_best_bid_ask(self, symbol: str) -> BestBidAsk:
        quotes = self.quotes.get(symbol, [])
        valid = [q for q in quotes if not q.is_stale()]
        if not valid:
            return None
        best_bid = max(valid, key=lambda q: q.bid)
        best_ask = min(valid, key=lambda q: q.ask)
        return BestBidAsk(
            bid=best_bid.bid,
            bid_size=best_bid.bid_size,
            bid_provider=best_bid.provider,
            ask=best_ask.ask,
            ask_size=best_ask.ask_size,
            ask_provider=best_ask.provider,
            spread_bps=int((best_ask.ask - best_bid.bid) / best_bid.bid * 10000)
        )

מה זה Smart Order Routing ואיך זה עובד?

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

class SmartOrderRouter:
    def route(self, order: ClientOrder, aggregator: LiquidityAggregator) -> RoutingPlan:
        available = aggregator.get_all_quotes(order.symbol)
        if order.type == 'market':
            return self.route_market(order, available)
        elif order.type == 'limit':
            return self.route_limit(order, available)

    def route_market(self, order: ClientOrder, quotes: list[LPQuote]) -> RoutingPlan:
        remaining = order.quantity
        plan = []
        sorted_quotes = sorted(
            quotes,
            key=lambda q: q.ask if order.side == 'buy' else -q.bid
        )
        for quote in sorted_quotes:
            if remaining <= 0:
                break
            fill_qty = min(remaining, quote.ask_size if order.side == 'buy' else quote.bid_size)
            plan.append(RoutingLeg(
                provider=quote.provider,
                quantity=fill_qty,
                expected_price=quote.ask if order.side == 'buy' else quote.bid
            ))
            remaining -= fill_qty
        if remaining > 0:
            raise InsufficientLiquidity(f"Could not route full order, {remaining} remaining")
        return RoutingPlan(legs=plan, total_quantity=order.quantity)
"}

מידע נוסף על עקרונות SOR ניתן למצוא ב־ויקיפדיה.

מה לבחור: CEX LP או DEX/AMM?

CEX LP מצטבר (B2Broker) נותן ספרידים של 0.01–0.05% לזוגות מובילים, אך דורש KYB ונפח חודשי. DEX/AMM (Uniswap) אינו דורש KYC וזמין לכל טוקן, אך הספרידים עשויים להיות גבוהים יותר (0.05–1%) ויש סיכון להפסד בלתי־קבוע (impermanent loss) בשימוש בבריכה עצמית. האסטרטגיה הטובה ביותר היא שילוב: זוגות מרכזיים דרך CEX LP, ארוכי זנב דרך DEX. חיסכון בספרידים יכול להגיע ל־50% בהשוואה להזמנות שוק ללא SOR. עלות אינטגרציית LP ממוצעת לבורסה נעה בין $20,000 ל־$100,000 בהתאם למורכבות, מספר הספקים ודרישות ההשהיה.

סקירת תהליך: מהבקשה לייצור

התהליך כולל: אנליטיקה (1–2 ימים), עיצוב (2–3 ימים), מימוש (1–2 שבועות), בדיקות (3–5 ימים), פריסה (1–2 ימים) ותמיכה שוטפת. אנו יכולים להעריך את הפרויקט שלכם תוך יום אחד — צרו קשר לייעוץ. הזמינו אינטגרציית LP סוהר וקבלו ארכיטקטורה מוכנה תוך 2–4 שבועות. קבלו אינטגרציית LP מוכנה לייצור עם אחריות uptime של 99.95%.