Order Book vs AMM: मार्केट माइक्रोस्ट्रक्चर और HFT

अगर आप अभी भी सोचते हैं कि एक्सचेंज पर ट्रेड लगाना सिर्फ «Buy» बटन दबाने का खेल है और उसके बाद कोई जादू होता है, तो भाई आपके लिए एक रियलिटी चेक है। माइक्रोसेकंड और मिलीसेकंड के लेवल पर मार्केट एक बेरहम जंग का मैदान (battlefield) है, जहां लिक्विडिटी एक रूप से दूसरे रूप में बहती है। यहां आपकी एग्जीक्यूशन स्पीड और पूल की एनाटॉमी तय करती है कि कौन तगड़ा प्रॉफिट छापेगा और किसे स्लिपेज (slippage) या टॉक्सिक फ्लो (toxic flow) का चूना लगेगा।

सेंट्रलाइज्ड ट्रेडिंग (TradFi और CEX) की दुनिया में ऑर्डर बुक (Order Book) का राज चलता है। वहीं दूसरी तरफ DeFi में AMM बेंचमार्क बन चुका है। लेकिन जब हम हाई-फ्रीक्वेंसी ट्रेडिंग (HFT) के लेवल पर उतरते हैं, तो इनके बीच का फर्क सिर्फ टेक्नोलॉजी का नहीं रह जाता—यह प्राइस डिस्कवरी, आर्बिट्राज और ऑर्डर एग्जीक्यूशन के पूरे खेल को बुनियादी तौर पर बदल देता है।

चलिए आज दोनों सिस्टम्स के हुड के अंदर झांककर लिक्विडिटी के मैकेनिक्स को खोलते हैं, यह समझते हैं कि छिपी हुई लागतें (hidden costs) कहां बैठी हैं और इस नॉलेज को प्रैक्टिकल ट्रेडिंग में कैसे इस्तेमाल करना है।

1. L2/L3 ऑर्डर बुक की एनाटॉमी: असल में कैसी दिखती है लिक्विडिटी

ज्यादातर रिटेल ट्रेडर्स को सिर्फ L2 ऑर्डर बुक दिखती है: जहां हर प्राइस लेवल पर एग्रीगेटेड वॉल्यूम होता है। लेकिन HFT एल्गोरिदम और इंस्टीट्यूशनल प्लेयर्स L3 (Order-by-Order) डेटा फीड पर काम करते हैं—यह रॉ डेटा का वो फ्लो है जहां हर एक इवेंट का अपना अलग यूनिक आइडेंटिफायर (order_id), सटीक टाइमस्टैम्प और कतार (queue) में फिक्स पोजीशन होती है।

Price-Time Priority (FIFO) का फंडा

ट्रेडिशनल मैचिंग इंजन (matching engine) में ऑर्डर्स सख्त रूल्स के हिसाब से एग्जीक्यूट होते हैं:

• प्राइस (जो सबसे बेहतरीन प्राइस देगा, उसे पहली प्रायोरिटी मिलेगी)।
• टाइम (अगर प्राइस सेम है, तो जो कतार में पहले आकर खड़ा हुआ, ऑर्डर उसका पहले फील होगा)।

इस टाइम कतार के चक्कर में मार्केट माइक्रोस्ट्रक्चर के दो खतरनाक इफ़ेक्ट पैदा होते हैं:

Adverse Selection (एडवर्स सिलेक्शन): अगर आपका लिमिट बाय ऑर्डर बहुत तेजी से फिल हो जाता है, तो इस बात का पूरा चांस है कि मार्केट में कोई बड़ा सेलर आक्रामक फ्लो (toxic flow) लेकर घुसा है, और अब प्राइस यहां से और नीचे गिरेगी।

Queue Position Value: किसी प्राइस लेवल पर कतार में सबसे आगे होने की अपने आप में एक वैल्यू होती है। हाई-फ्रीक्वेंसी बॉट्स लगातार ऑर्डर्स को कैंसिल और री-सबमिट करते रहते हैं (स्पूफिंग/लेयरिंग या अडैप्टिव लिक्विडिटी मैनेजमेंट की ट्रिक्स), ताकि अपनी इन्वेंट्री का रिस्क बढ़ाए बिना कतार में अपनी प्रायोरिटी बनाए रखें।

2. AMM: क्लासिक कांस्टेंट प्रोडक्ट से कंसंट्रेटेड लिक्विडिटी तक का सफर

AMM ऑर्डर बुक से बिल्कुल अलग तरीके से काम करता है: यहां ऑर्डर्स की कोई लाइन नहीं होती। प्राइस पूरी तरह से एक मैथमेटिकल इनवेरिएंट फंक्शन से तय होता है।

Constant Product (v2): x · y = k

क्लासिक Uniswap v2 में लिक्विडिटी शून्य से लेकर अनंत (infinity) तक पूरी कर्व पर फैली होती है।

जब कोई ट्रेडर Δx वॉल्यूम की डील करता है, तो वो फीस γ = (1 - fee) को काटते हुए पूल से Δy निकालता है:

Δy = (y · Δx · γ) / (x + Δx · γ)

यहां एग्जीक्यूशन प्राइस फिक्स नहीं होती, वो ऑर्डर एग्जीक्यूट होते वक्त ही कर्व पर आगे "स्लिप" (slip) होती है।

Concentrated Liquidity (v3 / Tick-based)

Uniswap v3 ने लिक्विडिटी प्रोवाइडेर्स (LPs) को अपना कस्टम प्राइस रेंज [P_a, P_b] सेट करने का ऑप्शन देकर AMM को एक तरह से ऑर्डर बुक जैसा बना दिया।

प्राइस को टिक्स (ticks) में बांटा गया है, जहां हर टिक का मतलब प्राइस में 0.01% (1 bps) का बदलाव होता है:

P(i) = 1.0001ⁱ

रेंज के अंदर लिक्विडिटी L एक "वर्चुअल" इनवेरिएंट की तरह काम करती है, लेकिन जैसे ही प्राइस किसी टिक की बाउंड्री को क्रॉस करती है, एक्टिव लिक्विडिटी अचानक से बदल जाती है। HFT आर्बिट्राजर्स के लिए इसका सीधा सा मतलब यह है: AMM v3 की ऑर्डर बुक डिस्क्रीट होती है, और टिक टूटने पर इसकी गहराई झटके से बदलती है।

3. कम्पेरिजन मैट्रिक्स: माइक्रोस्ट्रक्चर मैट्रिक्स

4. हिडन मैकेनिक्स: MEV, LVR और टॉक्सिक फ्लो

CEX ऑर्डर बुक में एक HFT ट्रेडर नैनोसेकंड्स की फिजिकल नेटवर्क लेटेंसी के लिए लड़ता है (एक्सचेंज डेटा सेंटर में कोलोकेशन, ऑप्टिकल फाइबर, FPGA बोर्ड्स)।

दूसरी तरफ DeFi में टाइम का कॉन्सेप्ट ही अलग है: यहां सारा खेल इस बात का है कि ब्लॉक के अंदर आपका ट्रांजैक्शन कहां स्ट्रक्चर होता है।

MEV (Maximal Extractable Value)

AMM में किसी ब्लॉक के अंदर ट्रांजैक्शन किस सीक्वेंस में लगेंगे, यह सर्चर्स (Searchers) और ब्लॉक बिल्डर्स (Builders) तय करते हैं। इससे कुछ खास HFT ट्रिक्स निकलकर आती हैं:

• Front-running / Back-running: ज्यादा प्रायोरिटी फीस (Priority Fee) देकर मेमपूल (mempool) में दूसरों के ट्रेड्स को हाईजैक करना।
• Sandwich Attacks: किसी बड़े रिटेल ऑर्डर से ठीक पहले खुद बाय करके प्राइस बढ़ाना और उसके ऑर्डर के तुरंत बाद सेल करके प्रॉफिट निकालना।

LVR (Loss-Versus-Rebalancing)

ज्यादातर लोग LP के रिस्क को सिर्फ इम्पर्मानेंट लॉस (IL) से नापते हैं। लेकिन HFT लेवल पर LVR मैट्रिक्स कहीं ज्यादा मायने रखता है, जिसे कोलंबिया यूनिवर्सिटी और Paradigm के रिसर्चर्स ने प्रपोज किया था।

LVR (Loss-Versus-Rebalancing) — यह AMM में किसी लिक्विडिटी प्रोवाइडर का वो नुकसान है, जो उसे CEX के एक्सटर्नल प्राइसेज का इस्तेमाल करके पोर्टफोलियो को रीबैलेंस करने के मुकाबले झेलना पड़ता है।

LVR की असली वजह है वोलेटिलिटी आर्बिट्राज। जब CEX पर प्राइस आगे निकल जाती है, तो AMM पूल पुरानी प्राइस (stale price) पर ही अटका रहता है। HFT आर्बिट्राजर इस स्प्रेड को देखते ही AMM से सस्ती लिक्विडिटी झपट लेता है और CEX पर उसकी हेजिंग कर लेता है। इसका नतीजा यह होता है कि AMM में लिक्विडिटी प्रोवाइडर हमेशा इंफॉर्म्ड फ्लो (toxic flow) के खिलाफ सबसे खराब प्राइस पर फिल होता है।

LVR ≈ (σ² / 8) · ∫₀^T S_t · L_t dt

जहां σ — एसेट की वोलेटिलिटी है, S_t — प्राइस है, और L_t — एक्टिव लिक्विडिटी है। निचोड़: मार्केट में जितनी ज्यादा वोलेटिलिटी होगी, LPs का उतना ही ज्यादा पैसा HFT आर्बिट्राजर्स की जेब में जाएगा।

5. हैंड्स-ऑन: AMM v3 vs L2 Depth कोटेशन कैलकुलेटर (Python स्क्रिप्ट)

अब सीधा कोड पर आते हैं। एक वर्किंग टूल बनाते हैं जो किसी दिए गए ऑर्डर के लिए L2 ऑर्डर बुक की गहराई और Constant Product AMM पूल की तुलना करके असली एग्जीक्यूशन प्राइस (स्लिपेज के साथ) कैलकुलेट करेगा।

यह कोड बिना किसी भारी थर्ड-पार्टी फ्रेमवर्क के एकदम क्लीन पायथन (Clean Python) में लिखा गया है।

from __future__ import annotations
from dataclasses import dataclass
from enum import Enum
from typing import List
class FeeMode(Enum):
    QUOTE = "quote"  # फीस आने वाले USDT से काटी जाती है
    BASE = "base"    # फीस प्राप्त हुए ETH से काटी जाती है
@dataclass
class AskLevel:
    price: float
    volume: float
class OrderBookL2:
    """
    L2 ऑर्डर बुक (Ask पक्ष / बिकवाली की ओर)।
    ETH/USDT जोड़ी का उदाहरण:
        price  = प्रति 1 ETH का USDT मान
        volume = ETH की मात्रा
    """
    def __init__(
        self,
        asks: List[tuple[float, float]],
        taker_fee: float = 0.001,
    ) -> None:
        if not (0 <= taker_fee < 1):
            raise ValueError("taker_fee की सीमा [0, 1) के बीच होनी चाहिए")
        self.taker_fee = float(taker_fee)
        self.asks: List[AskLevel] = []
        for price, volume in asks:
            if price <= 0:
                raise ValueError("मूल्य > 0 होना चाहिए")
            if volume <= 0:
                raise ValueError("मात्रा (Volume) > 0 होनी चाहिए")
            self.asks.append(
                AskLevel(
                    price=float(price),
                    volume=float(volume),
                )
            )
        self.asks.sort(key=lambda x: x.price)
    def best_ask(self) -> float:
        if not self.asks:
            raise ValueError("ऑर्डर बुक खाली है")
        return self.asks[0].price
    def spot_price(self) -> float:
        return self.best_ask()
    def total_liquidity_quote(self) -> float:
        return sum(
            level.price * level.volume
            for level in self.asks
        )
    def total_liquidity_base(self) -> float:
        return sum(
            level.volume
            for level in self.asks
        )
    def simulate_buy(
        self,
        amount_in_quote: float,
        mutate: bool = True,
        fee_mode: FeeMode = FeeMode.QUOTE,
    ) -> tuple[float, float]:
        """
        amount_in_quote का उपयोग करके मूल संपत्ति (Base Asset) खरीदें।
        रिटर्न करता है:
            (
                प्राप्त हुई मूल संपत्ति की मात्रा,
                औसत प्रभावी मूल्य
            )
        """
        if amount_in_quote <= 0:
            raise ValueError(
                "amount_in_quote > 0 होना चाहिए"
            )
        if fee_mode == FeeMode.QUOTE:
            quote_for_trade = (
                amount_in_quote *
                (1.0 - self.taker_fee)
            )
        else:
            quote_for_trade = amount_in_quote
        remaining_quote = quote_for_trade
        total_base_bought = 0.0
        new_levels: List[AskLevel] = []
        for level in self.asks:
            if remaining_quote <= 0:
                new_levels.append(level)
                continue
            level_cost = (
                level.price *
                level.volume
            )
            if remaining_quote >= level_cost:
                total_base_bought += level.volume
                remaining_quote -= level_cost
            else:
                base_from_level = (
                    remaining_quote /
                    level.price
                )
                total_base_bought += base_from_level
                remaining_volume = (
                    level.volume -
                    base_from_level
                )
                if remaining_volume > 1e-12:
                    new_levels.append(
                        AskLevel(
                            level.price,
                            remaining_volume,
                        )
                    )
                remaining_quote = 0.0
        if remaining_quote > 1e-9:
            raise ValueError(
                "ऑर्डर बुक में पर्याप्त तरलता (Liquidity) नहीं है"
            )
        if fee_mode == FeeMode.BASE:
            total_base_bought *= (
                1.0 - self.taker_fee
            )
        if total_base_bought <= 0:
            raise ValueError(
                "प्राप्त मात्रा शून्य है"
            )
        avg_price = (
            amount_in_quote /
            total_base_bought
        )
        if mutate:
            self.asks = new_levels
        return total_base_bought, avg_price
class ConstantProductAMM:
    """
    Uniswap V2 शैली AMM
    x = ETH
    y = USDT
    spot = y / x
    """
    def __init__(
        self,
        reserve_x: float,
        reserve_y: float,
        fee: float = 0.003,
    ) -> None:
        if reserve_x <= 0:
            raise ValueError(
                "reserve_x > 0 होना चाहिए"
            )
        if reserve_y <= 0:
            raise ValueError(
                "reserve_y > 0 होना चाहिए"
            )
        if not (0 <= fee < 1):
            raise ValueError(
                "fee की सीमा [0, 1) के बीच होनी चाहिए"
            )
        self.x = float(reserve_x)
        self.y = float(reserve_y)
        self.fee = float(fee)
    def spot_price(self) -> float:
        return self.y / self.x
    def invariant(self) -> float:
        return self.x * self.y
    def simulate_buy(
        self,
        amount_y_in: float,
        mutate: bool = True,
    ) -> tuple[float, float]:
        """
        USDT के बदले ETH खरीदें।
        रिटर्न करता है:
            (
                प्राप्त ETH,
                औसत मूल्य
            )
        """
        if amount_y_in <= 0:
            raise ValueError(
                "amount_y_in > 0 होना चाहिए"
            )
        y_effective = (
            amount_y_in *
            (1.0 - self.fee)
        )
        x_out = (
            self.x *
            y_effective
        ) / (
            self.y +
            y_effective
        )
        if x_out <= 0:
            raise ValueError(
                "प्राप्त मात्रा शून्य है"
            )
        if x_out >= self.x:
            raise ValueError(
                "पूल में पर्याप्त तरलता नहीं है"
            )
        avg_price = (
            amount_y_in /
            x_out
        )
        if mutate:
            self.x -= x_out
            self.y += amount_y_in
        return x_out, avg_price
def print_trade_result(
    title: str,
    received: float,
    avg_price: float,
    spot_price: float,
) -> None:
    slippage = (
        (avg_price - spot_price)
        / spot_price
    ) * 100
    print(
        f"{title:<12}"
        f" प्राप्त हुआ: {received:.6f}"
        f" | औसत मूल्य: {avg_price:,.4f}"
        f" | स्लिपेज (Slippage): {slippage:.4f}%"
    )
def main() -> None:
    asks = [
        (3000.0, 1.5),
        (3001.0, 2.0),
        (3002.5, 5.0),
        (3005.0, 10.0),
        (3010.0, 25.0),
    ]
    orderbook = OrderBookL2(
        asks=asks,
        taker_fee=0.001,
    )
    amm = ConstantProductAMM(
        reserve_x=1000.0,
        reserve_y=3_000_000.0,
        fee=0.003,
    )
    trade_size = 15_000.0
    ob_spot = orderbook.spot_price()
    amm_spot = amm.spot_price()
    ob_received, ob_avg = orderbook.simulate_buy(
        amount_in_quote=trade_size,
        mutate=True,
        fee_mode=FeeMode.QUOTE,
    )
    amm_received, amm_avg = amm.simulate_buy(
        amount_y_in=trade_size,
        mutate=True,
    )
    print(
        f"\n=== {trade_size:,.2f} USDT के लिए निष्पादन की तुलना ===\n"
    )
    print_trade_result(
        "ORDERBOOK",
        ob_received,
        ob_avg,
        ob_spot,
    )
    print_trade_result(
        "AMM V2",
        amm_received,
        amm_avg,
        amm_spot,
    )
    print("\n=== सौदे के बाद की स्थिति ===\n")
    if orderbook.asks:
        print(
            f"सर्वश्रेष्ठ मूल्य (Best Ask): "
            f"{orderbook.best_ask():,.4f}"
        )
    else:
        print("ऑर्डर बुक पूरी तरह से खाली हो चुकी है")
    print(
        f"AMM स्पॉट मूल्य: "
        f"{amm.spot_price():,.4f}"
    )
    print(
        f"AMM रिजर्व: "
        f"{amm.x:.6f} ETH | "
        f"{amm.y:.2f} USDT"
    )
if __name__ == "__main__":
    main()

रिजल्ट्स को कैसे समझें

गहरे AMM पूल्स में छोटे ऑर्डर्स ना के बराबर स्लिपेज के साथ फिल होते हैं, लेकिन जैसे-जैसे वॉल्यूम बढ़ता है, AMM में प्राइस एक कॉन्वेक्स कर्व (convex curve) पर तेजी से ऊपर भागती है। दूसरी ओर ऑर्डर बुक में सारा खेल भारी ऑर्डर्स यानी "दीवारों" (liquidity walls) का होता है। अगर ऑर्डर बुक में लिक्विडिटी हल्की है, तो आपका ऑर्डर कई लेवल्स को चीरता हुआ निकल जाएगा और आपको AMM से भी बदतर प्राइस स्लिपेज देखने को मिलेगी।

6. हाइब्रिड मॉडल्स: DEXs कैसे Order Book लागू कर रहे हैं और CEXs क्यों AMM की तरफ देख रहे हैं

ऑर्डर बुक्स और AMMs के बीच की बाउंड्री अब धीरे-धीरे धुंधली हो रही है। हाई-फ्रीक्वेंसी ट्रेडर्स (HFTs) और इंस्टीट्यूशनल प्लेयर्स क्लासिक Uniswap v2 की सीमाओं से जल्दी ही टकरा गए: कम कैपिटल एफिशिएंसी और कॉम्प्लेक्स लिमिट ऑर्डर्स (Stop-loss, Take-profit, Iceberg) लगाने की असमर्थता ने DEXs को एक्टिव मार्केट मेकिंग के लिए काफी असुविधाजनक बना दिया।

इस वजह से एक बड़ा इवोल्यूशनरी शिफ्ट आया और हाइब्रिड आर्किटेक्चर का जन्म हुआ।

1. On-Chain और L2 Order Books (dYdX, Hyperliquid, Vertex)

हाई-परफॉरमेंस L1/L2 नेटवर्क (Aptos, Sui, Arbitrum) और स्पेशलाइज्ड AppChains के आने के बाद, सीधे ऑन-चेन पर ही फुल-फ्लेज्ड ऑर्डर बुक्स चलाना मुमकिन हो गया है।

Off-chain matching + On-chain settlement: ऑर्डर मैचिंग इंजन अल्ट्रा-फास्ट ऑफ-चेन इंजनों पर चलते हैं (< 10 ms की लेटेंसी हासिल करने के लिए), जबकि एग्जीक्यूशन के रिजल्ट्स और मार्जिन रिक्वायरमेंट्स स्मार्ट कॉन्ट्रैक्ट्स में सेटल होते हैं।

Fully On-chain (Hyperliquid, Serum/Ellipsis): पूरी ऑर्डर बुक सीधे ब्लॉकचेन कंसेंसेस पर ही लाइव रहती है। यहाँ सबसे बड़ी चुनौती भारी-भरकम ट्रांजेक्शन वॉल्यूम को संभालना है: HFT में ऑर्डर्स को बदलना या कैंसिल करना (Cancel/Replace) कुल इनकमिंग ट्रांजेक्शंस का 95–98% तक होता है।

2. Intent-Based आर्किटेक्चर और RFQ (Request for Quote)

"Intents" मॉडल (Uniswap X, 1inch Fusion, CoW Protocol) असल में ऑर्डर एग्जीक्यूशन में इंस्टीट्यूशनल एप्रोच को वापस लाता है।

ट्रेडर किसी स्पेसिफिक पूल के साथ सीधे ट्रांजेक्शन साइन करने के बजाय अपना इंटेंट यानी इरादा साइन करता है (जैसे: «मुझे 100 ETH के बदले कम से कम 300,000 USDC चाहिए»)। इसके बाद थर्ड-पार्टी एग्जीक्यूटर्स (Fillers / Solvers) का नेटवर्क किसी भी लिक्विडिटी सोर्स का इस्तेमाल करके उस ऑर्डर को फिल करने के लिए आपस में होड़ लगाता है — चाहे CEX हो, प्राइवेट मार्केट मेकर इन्वेंट्री हो या DEX।

एक एक्टिव ट्रेडर के लिए इसका मतलब है जीरो स्लिपेज और MEV-सैंडविच अटैक से पूरी सुरक्षा: स्लिपेज और एग्जीक्यूशन का सारा रिस्क Solver खुद उठाता है और क्रॉस-एसेट आर्बिट्राज से अपना प्रॉफिट बनाता है।

7. प्रैक्टिकल गाइड: CEX L2 Order Book और AMM v2 के बीच एडवांस्ड आर्बिट्राज स्क्रिप्ट

रियल वर्ल्ड में, HFT बोट्स CEX और AMM के बीच प्राइस इमबैलेंस (कीमतों के अंतर) को लगातार ट्रैक करते रहते हैं। अगर CEX पर किसी एसेट की कीमत मार्केट बाइंग की वजह से अचानक बढ़ जाती है, तो AMM पूल कुछ देर के लिए «पुराने प्राइस» (stale price) पर ही अटका रहता है। आर्बिट्राजर AMM से बाय करके उसके प्राइस को CEX के लेवल तक पंप कर देता है और उस खरीदे गए वॉल्यूम को वापस CEX पर डंप कर देता है।

नीचे एक वर्किंग Python स्क्रिप्ट दी गई है, जो AMM फीस, CEX ऑर्डर बुक की गहराई और मेकर/टेकर फीस को ध्यान में रखते हुए रियल टाइम में ऑप्टिमल आर्बिट्राज ट्रेड साइज (dx) कैलकुलेट करती है।

from __future__ import annotations
from dataclasses import dataclass
from typing import List, Dict, Any
@dataclass
class BidLevel:
    price: float
    volume: float
class OrderBookSide:
    """
    ऑर्डर बुक की Bid साइड।
    price  = खरीद मूल्य
    volume = बेस एसेट का वॉल्यूम
    """
    def __init__(self, bids: List[tuple[float, float]]):
        self.bids: List[BidLevel] = []
        for price, volume in bids:
            if price <= 0:
                raise ValueError("कीमत > 0 होनी चाहिए")
            if volume <= 0:
                raise ValueError("वॉल्यूम > 0 होना चाहिए")
            self.bids.append(
                BidLevel(
                    float(price),
                    float(volume)
                )
            )
        self.bids.sort(
            key=lambda x: x.price,
            reverse=True
        )
    def is_empty(self) -> bool:
        return len(self.bids) == 0
    def best_bid(self) -> float:
        if self.is_empty():
            raise ValueError("ऑर्डर बुक खाली है")
        return self.bids[0].price
    def cumulative_levels(self) -> List[tuple[float, float]]:
        """
        लिक्विडिटी में बदलाव के पॉइंट्स लौटाता है।
        [
            (2 ETH, 2 ETH तक का VWAP),
            (7 ETH, 7 ETH तक का VWAP),
            ...
        ]
        """
        result = []
        cumulative_x = 0.0
        cumulative_y = 0.0
        for level in self.bids:
            cumulative_x += level.volume
            cumulative_y += level.volume * level.price
            result.append(
                (
                    cumulative_x,
                    cumulative_y
                )
            )
        return result
    def execute_sell(
        self,
        amount_x: float
    ) -> tuple[float, float]:
        """
        ऑर्डर बुक में amount_x बेचना।
        आउटपुट:
        (
            प्राप्त_USDT,
            VWAP
        )
        """
        if amount_x <= 0:
            raise ValueError(
                "amount_x > 0 होना चाहिए"
            )
        remaining_x = amount_x
        received_y = 0.0
        for level in self.bids:
            if remaining_x <= 0:
                break
            executed = min(
                remaining_x,
                level.volume
            )
            received_y += (
                executed *
                level.price
            )
            remaining_x -= executed
        if remaining_x > 1e-9:
            raise ValueError(
                "ऑर्डर बुक में पर्याप्त लिक्विडिटी नहीं है"
            )
        vwap = received_y / amount_x
        return received_y, vwap
class AMMPool:
    """
    Constant Product AMM
    x = ETH
    y = USDT
    """
    def __init__(
        self,
        reserve_x: float,
        reserve_y: float,
        fee: float = 0.003
    ):
        if reserve_x <= 0:
            raise ValueError(
                "reserve_x > 0 होना चाहिए"
            )
        if reserve_y <= 0:
            raise ValueError(
                "reserve_y > 0 होना चाहिए"
            )
        if not (0 <= fee < 1):
            raise ValueError(
                "fee की वैल्यू [0,1) की रेंज में होनी चाहिए"
            )
        self.x = float(reserve_x)
        self.y = float(reserve_y)
        self.fee = float(fee)
    def spot_price(self) -> float:
        return self.y / self.x
    def calculate_out_x(
        self,
        amount_y_in: float
    ) -> float:
        if amount_y_in <= 0:
            raise ValueError(
                "amount_y_in > 0 होना चाहिए"
            )
        y_effective = (
            amount_y_in *
            (1.0 - self.fee)
        )
        x_out = (
            self.x *
            y_effective
        ) / (
            self.y +
            y_effective
        )
        return x_out
    def calculate_required_y_for_x(
        self,
        target_x_out: float
    ) -> float:
        """
        AMM फॉर्मूले का रिवर्स।
        target_x_out प्राप्त करने के लिए
        कितना USDT डिपॉजिट करना होगा।
        """
        if target_x_out <= 0:
            raise ValueError(
                "target_x_out > 0 होना चाहिए"
            )
        if target_x_out >= self.x:
            raise ValueError(
                "पूरा रिज़र्व बाहर नहीं निकाला जा सकता"
            )
        y_effective = (
            target_x_out *
            self.y
        ) / (
            self.x -
            target_x_out
        )
        amount_y_in = (
            y_effective /
            (1.0 - self.fee)
        )
        return amount_y_in
def find_optimal_arbitrage(
    amm: AMMPool,
    cex_bids: OrderBookSide,
    cex_fee: float = 0.001
) -> Dict[str, Any]:
    if not (0 <= cex_fee < 1):
        raise ValueError(
            "cex_fee [0,1) की रेंज में होना चाहिए"
        )
    if cex_bids.is_empty():
        return {
            "opportunity": False,
            "reason": "CEX ऑर्डर बुक खाली है"
        }
    best_bid = cex_bids.best_bid()
    if (
        best_bid *
        (1.0 - cex_fee)
        <=
        amm.spot_price()
    ):
        return {
            "opportunity": False,
            "reason": "कोई स्प्रेड मौजूद नहीं है"
        }
    best_result = None
    best_profit = float("-inf")
    cumulative = cex_bids.cumulative_levels()
    for cumulative_x, cumulative_y in cumulative:
        try:
            required_usdt = (
                amm.calculate_required_y_for_x(
                    cumulative_x
                )
            )
            gross_usdt = cumulative_y
            net_usdt = (
                gross_usdt *
                (1.0 - cex_fee)
            )
            profit = (
                net_usdt -
                required_usdt
            )
            if profit > best_profit:
                avg_buy_price = (
                    required_usdt /
                    cumulative_x
                )
                avg_sell_price = (
                    gross_usdt /
                    cumulative_x
                )
                amm_spot = (
                    amm.spot_price()
                )
                impact_pct = (
                    (
                        avg_buy_price -
                        amm_spot
                    )
                    /
                    amm_spot
                ) * 100
                roi_pct = (
                    profit /
                    required_usdt
                ) * 100
                best_profit = profit
                best_result = {
                    "opportunity": True,
                    "input_usdt_amm": required_usdt,
                    "bought_x": cumulative_x,
                    "gross_usdt_cex": gross_usdt,
                    "net_usdt_cex": net_usdt,
                    "net_profit_usdt": profit,
                    "roi_pct": roi_pct,
                    "amm_spot_price": amm_spot,
                    "amm_avg_buy_price": avg_buy_price,
                    "amm_price_impact_pct": impact_pct,
                    "cex_vwap": avg_sell_price,
                }
        except ValueError:
            continue
    if best_result is None:
        return {
            "opportunity": False,
            "reason": "लिक्विडिटी नाकाफी है"
        }
    if best_result["net_profit_usdt"] <= 0:
        return {
            "opportunity": False,
            "reason": "स्लिपेज से सारा प्रॉफिट खत्म हो रहा है"
        }
    return best_result
def main():
    amm = AMMPool(
        reserve_x=1000.0,
        reserve_y=3_000_000.0,
        fee=0.003
    )
    cex = OrderBookSide([
        (3050.0, 2.0),
        (3048.0, 5.0),
        (3045.0, 10.0),
        (3040.0, 20.0),
        (3030.0, 50.0),
    ])
    result = find_optimal_arbitrage(
        amm,
        cex,
        cex_fee=0.0005
    )
    print(
        "\n=== आर्बिट्राज सर्च का रिजल्ट ===\n"
    )
    if not result["opportunity"]:
        print(
            f"स्टेटस: कैंसिल\n"
            f"वजह: {result['reason']}"
        )
        return
    print("स्टेटस: अपॉर्चुनिटी मिली")
    print()
    print(
        f"AMM इनपुट: "
        f"${result['input_usdt_amm']:,.2f}"
    )
    print(
        f"खरीदा गया ETH: "
        f"{result['bought_x']:.6f}"
    )
    print(
        f"CEX ग्रॉस रेवेन्यू: "
        f"${result['gross_usdt_cex']:,.2f}"
    )
    print(
        f"CEX नेट रेवेन्यू: "
        f"${result['net_usdt_cex']:,.2f}"
    )
    print(
        f"नेट प्रॉफिट: "
        f"${result['net_profit_usdt']:,.2f}"
    )
    print(
        f"ROI: "
        f"{result['roi_pct']:.4f}%"
    )
    print(
        f"AMM स्पॉट प्राइस: "
        f"{result['amm_spot_price']:.4f}"
    )
    print(
        f"AMM एवरेज बाय प्राइस: "
        f"{result['amm_avg_buy_price']:.4f}"
    )
    print(
        f"AMM प्राइस इंपैक्ट: "
        f"{result['amm_price_impact_pct']:.4f}%"
    )
    print(
        f"CEX VWAP: "
        f"{result['cex_vwap']:.4f}"
    )
if __name__ == "__main__":
    main()

8. ट्रेडर्स के लिए काम की सीख: «अज्ञानता का टैक्स» भरने से कैसे बचें

मार्केट माइक्रोस्ट्रक्चर को समझना केवल किताबों तक सीमित थ्योरी नहीं है। यह एक ऐसा टूल है जो आपके कैपिटल को छिपे हुए लीकेज और नुकसान से बचाता है।

• अपनी जरूरतों के हिसाब से सही ऑर्डर टाइप चुनें: CEX पर बड़ा वॉल्यूम सीधे «मार्केट ऑर्डर» (Market Order) से बाय करने पर आपका ऑर्डर बुक के कई लेवल्स से टकराएगा, जिससे भारी नेगेटिव स्लिपेज मिलना तय है। अगर आपको तुरंत एग्जीक्यूशन चाहिए ही, तो IOC (Immediate-or-Cancel) या FOK (Fill-or-Kill) ऑर्डर्स का इस्तेमाल करें और अपनी वर्स्ट-केस एक्सेप्टेबल प्राइस तय करें।
• सिर्फ स्प्रेड मत देखें, इफेक्टिव डेप्थ कैलकुलेट करें: L2 पर केवल $0.01 का टाइट स्प्रेड अक्सर एक छलावा होता है। अगर बेस्ट Bid/Ask पर केवल $100 की लिक्विडिटी है, तो आपका $50,000 का ऑर्डर पूरी ऑर्डर बुक को चीरता हुआ बहुत खराब प्राइस पर एग्जीक्यूट होगा।
• AMM में टॉक्सिक फ्लो का ध्यान रखें: अगर आप किसी बड़ी न्यूज या हाई वोलाटिलिटी के समय Uniswap v3 में टाइट रेंज में लिक्विडिटी प्रोवाइड कर रहे हैं, तो आप सीधे HFT-आर्बिट्राजर्स के निशाने पर हैं। LVR (Loss-Versus-Rebalancing) मीट्रिक मिनटों में आपकी फीस से होने वाली सारी कमाई चट कर जाएगी।
• DEX पर MEV से खुद को सुरक्षित रखें: AMM पर ट्रेड करते समय हमेशा Slippage Tolerance सीमित रखें (इसे 0.1–0.3% से ज्यादा न रखें) या प्राइवेट RPC नोड्स (जैसे Flashbots Protect / MEV-Blocker) का इस्तेमाल करें ताकि आपका ट्रांजेक्शन पब्लिक मेमपूल में न जाए और सैंडविच अटैक से बचा रहे।

कमेंट्स में जरूर बताएं कि बड़े ऑर्डर्स एग्जीक्यूट करते समय आपको सबसे ज्यादा कितना स्लिपेज झेलना पड़ता है, और आप अपने डेली ट्रेड्स के लिए कौन सा मॉडल (CEX Order Book या DEX AMM) ज्यादा पसंद करते हैं!