Order Book vs AMM: Piyasa Mikroyapısı ve HFT Arbitrajı

Borsadaki bir işlemin sadece "Buy" butonuna basmaktan ve ardından gerçekleşen bir büyüden ibaret olduğunu düşünüyorsanız, size kötü haberlerim var. Mikrosaniye ve milisaniye seviyesinde piyasa, likiditenin bir formdan diğerine aktığı; emir iletim hızının ve havuzun anatomisinin kimin kâr edeceğini, kimin ise kaymaya (slippage) ve toksik akışa (toxic flow) hesap ödeyeceğini belirlediği sert bir savaş alanıdır.

Merkezi ticarette (TradFi ve CEX) krallık Emir Defteri'nindir (Order Book). DeFi tarafında ise standart AMM oldu. Ancak yüksek frekanslı alım satım (HFT) seviyesine indiğimizde aralarındaki fark sadece teknolojik değildir; fiyatlandırma mekanizmasını, arbitrajı ve emirlerin gerçekleşme şeklini temelden değiştirir.

Gelin, her iki sistemin de kaputunun altındaki likidite mekanizmasının nasıl çalıştığına, gizli maliyetlerin nerede yattığına ve bu bilgileri pratikte nasıl kullanabileceğimize yakından bakalım.

1. L2/L3 Tahtasının Anatomisi: Likidite Gerçekte Nasıl Görünür?

Bireysel yatırımcıların çoğu L2 tahtasını görür: her fiyat seviyesindeki toplam hacimler. Ancak HFT algoritmaları ve kurumsallar L3 (Order-by-Order) ile çalışır. Burası, her olayın kendine has bir kimliğe (order_id), hassas bir zaman damgasına ve kuyrukta bir konuma sahip olduğu ham veri akışıdır.

Price-Time Priority (FIFO) Prensibi

Klasik bir eşleştirme motorunda (matching engine) emirler kesin bir öncelikle eşleşir:

• Fiyat (En iyi fiyat önceliği alır).
• Zaman (Fiyatlar eşitse, kuyruğa ilk giren önce eşleşir).

Zaman öncelikli kuyruk nedeniyle mikro yapıda iki kritik etki ortaya çıkar:

Adverse Selection (Ters Seçilim): Alış yönlü limit emriniz hızla gerçekleşiyorsa, piyasaya agresif bir akışla (toxic flow) büyük bir satıcının girmiş olması ve fiyatın düşmeye devam etmesi muhtemeldir.

Queue Position Value (Kuyruk Pozisyon Değeri): Bir fiyat seviyesindeki kuyruğun en başında olmak başlı başına bir değere sahiptir. Yüksek frekanslı botlar, ekstra envanter riski almadan önceliği korumak adına emirleri sürekli iptal edip yeniden girer (Spoofing/Layering mekanizması veya adaptif likidite yönetimi).

2. AMM: Klasik Constant Product'tan Yoğunlaştırılmış Likiditeye

AMM, emir tahtasından temelden ayrılır: burada emir kuyruğu yoktur. Fiyat, matematiksel bir değişmez (invariant) fonksiyonu ile belirlenir.

Constant Product (v2): x · y = k

Klasik Uniswap v2'de likidite sıfırdan sonsuza kadar dağılmıştır.

Δx hacminde bir işlem yapıldığında, yatırımcı havuzdan komisyon γ = (1 - fee) düşülerek hesaplanan Δy miktarını çeker:

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

Gerçekleşme fiyatı sabit değildir, işlem anında eğri boyunca "kayar".

Concentrated Liquidity (v3 / Tick-based)

Uniswap v3, likidite sağlayıcılarının (LP) özel aralıklar [P_a, P_b] belirlemesine izin vererek AMM'i adeta bir emir tahtasına dönüştürdü.

Fiyat tiklere (ticks) bölünmüştür ve her tik %0.01'lik (1 bps) bir fiyat değişimine karşılık gelir:

P(i) = 1.0001ⁱ

Belirli bir aralıktaki likidite L, "sanal" bir değişmez gibi çalışır; ancak bir tik sınırı aşıldığında aktif likidite aniden değişir. Yüksek frekanslı bir arbitrajcı için bu şu anlama gelir: AMM v3 tahtası kesiklidir ve tikler kırıldıkça derinliği basamaklı olarak değişir.

3. Karşılaştırmalı Analiz: Microstructure Matrix

4. Gizli Mekanizmalar: MEV, LVR ve Toksik Akış

CEX tahtasında bir HFT oyuncusu, fiziksel ağ gecikmesinin (borsanın veri merkezinde colocation, fiber optik, FPGA kartları) nanosaniyeleri için savaşır.

DeFi tarafında ise zaman kavramı bükülür: burada temel rolü bloğun yapılandırılması oynar.

MEV (Maximal Extractable Value)

AMM'de blok içindeki işlemlerin sırası arayıcılar (Searchers) ve blok kurucuları (Builders) tarafından belirlenir. Bu durum özel HFT mekanizmaları doğurur:

• Front-running / Back-running: Daha yüksek komisyon (Priority Fee) teklif ederek mempool'daki işlemlerin önüne geçme veya arkasına takılma.
• Sandwich Attacks: Fiyatı yükseltmek için büyük bir kullanıcı işleminden önce alım yapmak ve hemen ardından satarak kârı realize etmek.

LVR (Loss-Versus-Rebalancing)

Herkes LP risklerini Impermanent Loss (IL) üzerinden hesaplamaya alışkındır. Ancak yüksek frekans seviyesinde, Columbia Üniversitesi ve Paradigm araştırmacıları tarafından ortaya konan LVR metriği çok daha kritiktir.

LVR (Loss-Versus-Rebalancing) — harici fiyatlar kullanılarak CEX üzerinde sürekli yeniden dengelenen (rebalanced) aynı portföye kıyasla, AMM'deki likidite sağlayıcısının yaşadığı sistematik kayıptır.

LVR'nin sebebi volatilite arbitrajıdır. CEX tarafında fiyat ilerlediğinde, AMM havuzunda eski fiyat (stale price) kalır. HFT arbitrajcısı bu makası görür, AMM'deki ucuz likiditeyi toplar ve CEX'te pozisyonunu kapatır. AMM'deki likidite sağlayıcısı her zaman bilgili akışa (toxic flow) karşı en kötü fiyattan eşleşmiş olur.

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

Burada σ varlık volatilitesi, S_t fiyat, L_t ise aktif likiditedir. Özetle: Piyasadaki volatilite ne kadar yüksekse, LP'ler HFT arbitrajcılarına o kadar çok para kaptırır.

5. Pratik: AMM v3 vs L2 Derinlik Fiyatlama Python Betiği

Koda geçelim. L2 tahtasının derinliğini ve Constant Product AMM havuzunu karşılaştırarak, örnek bir emir için gerçek gerçekleşme fiyatını (fiyat kayması dahil) hesaplayan çalışan bir araç yazacağız.

Kod, hantal üçüncü taraf kütüphaneler olmadan saf Python ile yazılmıştır.

from __future__ import annotations
from dataclasses import dataclass
from enum import Enum
from typing import List
class FeeMode(Enum):
    QUOTE = "quote"  # komisyon giren USDT'den kesilir
    BASE = "base"    # komisyon alınan ETH'den kesilir
@dataclass
class AskLevel:
    price: float
    volume: float
class OrderBookL2:
    """
    L2 tahtası (Ask tarafı).
    ETH/USDT çifti örneği:
        price  = 1 ETH için 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) aralığında olmalıdır")
        self.taker_fee = float(taker_fee)
        self.asks: List[AskLevel] = []
        for price, volume in asks:
            if price <= 0:
                raise ValueError("Fiyat > 0 olmalıdır")
            if volume <= 0:
                raise ValueError("Hacim > 0 olmalıdır")
            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("Tahta boş")
        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 karşılığında baz varlık alımı.
        Dönen değerler:
            (
                alınan_baz_varlık,
                ortalama_efektif_fiyat
            )
        """
        if amount_in_quote <= 0:
            raise ValueError(
                "amount_in_quote > 0 olmalıdır"
            )
        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(
                "Tahtada yeterli likidite yok"
            )
        if fee_mode == FeeMode.BASE:
            total_base_bought *= (
                1.0 - self.taker_fee
            )
        if total_base_bought <= 0:
            raise ValueError(
                "Sıfır hacim elde edildi"
            )
        avg_price = (
            amount_in_quote /
            total_base_bought
        )
        if mutate:
            self.asks = new_levels
        return total_base_bought, avg_price
class ConstantProductAMM:
    """
    Uniswap V2 stili 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 olmalıdır"
            )
        if reserve_y <= 0:
            raise ValueError(
                "reserve_y > 0 olmalıdır"
            )
        if not (0 <= fee < 1):
            raise ValueError(
                "fee [0, 1) aralığında olmalıdır"
            )
        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 ile ETH alımı.
        Dönen değerler:
            (
                alınan_ETH,
                ortalama_fiyat
            )
        """
        if amount_y_in <= 0:
            raise ValueError(
                "amount_y_in > 0 olmalıdır"
            )
        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(
                "Sıfır hacim elde edildi"
            )
        if x_out >= self.x:
            raise ValueError(
                "Havuzda yeterli likidite yok"
            )
        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" Alınan: {received:.6f}"
        f" | Ortalama Fiyat: {avg_price:,.4f}"
        f" | Fiyat Kayması: {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 Tutarındaki "
        f"Emrin Karşılaştırılması ===\n"
    )
    print_trade_result(
        "ORDERBOOK",
        ob_received,
        ob_avg,
        ob_spot,
    )
    print_trade_result(
        "AMM V2",
        amm_received,
        amm_avg,
        amm_spot,
    )
    print("\n=== İşlem Sonrası Durum ===\n")
    if orderbook.asks:
        print(
            f"Best Ask: "
            f"{orderbook.best_ask():,.4f}"
        )
    else:
        print("Tahtadaki tüm satış emirleri süpürüldü")
    print(
        f"AMM Spot: "
        f"{amm.spot_price():,.4f}"
    )
    print(
        f"AMM Rezervleri: "
        f"{amm.x:.6f} ETH | "
        f"{amm.y:.2f} USDT"
    )
if __name__ == "__main__":
    main()

Sonuçlar Nasıl Yorumlanmalı?

Derin AMM havuzlarında küçük emirler minimum fiyat kaymasıyla gerçekleşir; ancak hacim büyüdükçe AMM'deki fiyat konveks bir eğri boyunca tırmanır. Emir tahtasında ise her şey "likidite duvarlarına" (liquidity walls) bağlıdır. Tahta sığsa, birkaç seviyeyi tek seferde delip geçer ve AMM'dekinden çok daha kötü bir maliyetle karşı karşıya kalabilirsiniz.

6. Hibrit Modeller: DEX'ler Nasıl Order Book Uyguluyor ve CEX'ler Neden AMM'e Göz Dikiyor?

Emir defterleri (Order Book) ile AMM'ler arasındaki çizgi giderek bulanıklaşıyor. Yüksek frekanslı tüccarlar (HFT) ve kurumsal oyuncular, klasik Uniswap v2'nin sunduğu limitlere hızlıca çarptı: Düşük sermaye verimliliği ve gelişmiş limit emirlerin (Stop-loss, Take-profit, Iceberg) eksikliği, DEX'leri aktif piyasa yapıcılığı (market making) için oldukça elverişsiz kılıyordu.

Bu durum evrimsel bir kırılmaya yol açtı ve hibrit mimarilerin doğmasını sağladı.

1. On-Chain ve L2 Order Book'lar (dYdX, Hyperliquid, Vertex)

Yüksek performanslı L1/L2 ağlarının (Aptos, Sui, Arbitrum) ve özelleştirilmiş AppChain'lerin ortaya çıkmasıyla birlikte, doğrudan blokzincir üzerinde eksiksiz emir defterleri çalıştırmak mümkün hale geldi.

Off-chain matching + On-chain settlement: Emir eşleştirme motorları, milisaniyenin altında gecikme sürelerine (< 10 ms) ulaşmak için zincir dışındaki ultra hızlı motorlarda çalışırken, işlem sonuçları ve marjin gereksinimleri akıllı sözleşmelerde sabitlenir.

Fully On-chain (Hyperliquid, Serum/Ellipsis): Emir defteri tamamen blokzincir konsensüsü içinde yaşar. Buradaki en büyük zorluk inanılmaz işlem hacimlerini yönetmektir: HFT tarafında emir güncelleme ve iptalleri (Cancel/Replace), tüm gelen işlemlerin %95–98'ini oluşturur.

2. Intent-Based Mimari ve RFQ (Request for Quote)

"Intent" (Niyet) modeli (Uniswap X, 1inch Fusion, CoW Protocol), özünde kurumsal emir yürütme yaklaşımını DeFi'a geri getiriyor.

Yatırımcı belirli bir havuzla etkileşime giren bir işlem imzalamak yerine, bir niyet imzalar (örneğin: «100 ETH karşılığında en az 300,000 USDC almak istiyorum»). Ardından, üçüncü taraf yürütücülerden oluşan bir ağ (Fillers / Solvers), emri yerine getirmek için yarışır — ister CEX, ister özel market maker envanteri, ister DEX olsun her türlü likidite kaynağını kullanabilirler.

Aktif bir trader için bu, sıfır kayma (slippage) ve MEV sandwich saldırılarına karşı tam koruma demektir: Fiyat kayması ve yürütme riskinin tamamını Solver üstlenir ve varlıklar arası arbitrajdan kendi kârını çıkarır.

7. Pratik: CEX L2 Order Book ve AMM v2 Arasında Gelişmiş Arbitraj Betiği

Pratikte HFT botları, CEX ve AMM arasındaki fiyat dengesizliklerini anlık olarak avlar. CEX tarafında piyasa alımları nedeniyle bir varlığın fiyatı fırlarsa, AMM havuzu bir süreliğine «güncelliğini yitirmiş» (stale) fiyatta kalır. Arbitrajcı, AMM'den alım yaparak fiyatı CEX seviyesine çeker ve aldığı hacmi CEX'te geri satar (dump eder).

Aşağıda AMM komisyonunu, CEX emir defteri derinliğini ve maker/taker komisyonlarını hesaba katarak gerçek zamanlı optimal arbitraj miktarını (dx) hesaplayan çalışan bir Python betiği yer alıyor.

from __future__ import annotations
from dataclasses import dataclass
from typing import List, Dict, Any
@dataclass
class BidLevel:
    price: float
    volume: float
class OrderBookSide:
    """
    Emir defterinin Alış (Bid) tarafı.
    price  = alış fiyatı
    volume = baz varlığın hacmi
    """
    def __init__(self, bids: List[tuple[float, float]]):
        self.bids: List[BidLevel] = []
        for price, volume in bids:
            if price <= 0:
                raise ValueError("Fiyat > 0 olmalıdır")
            if volume <= 0:
                raise ValueError("Hacim > 0 olmalıdır")
            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("Emir defteri boş")
        return self.bids[0].price
    def cumulative_levels(self) -> List[tuple[float, float]]:
        """
        Likidite değişim noktalarını döndürür.
        [
            (2 ETH, 2 ETH'ye kadar VWAP),
            (7 ETH, 7 ETH'ye kadar 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]:
        """
        Emir defterine amount_x miktarında satış yapılması.
        Döndürür:
        (
            alınan_USDT,
            VWAP
        )
        """
        if amount_x <= 0:
            raise ValueError(
                "amount_x > 0 olmalıdır"
            )
        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(
                "Emir defterinde yeterli likidite yok"
            )
        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 olmalıdır"
            )
        if reserve_y <= 0:
            raise ValueError(
                "reserve_y > 0 olmalıdır"
            )
        if not (0 <= fee < 1):
            raise ValueError(
                "fee [0,1) aralığında olmalıdır"
            )
        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 olmalıdır"
            )
        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 formülünün tersi.
        target_x_out elde etmek için
        ne kadar USDT yatırılmalı.
        """
        if target_x_out <= 0:
            raise ValueError(
                "target_x_out > 0 olmalıdır"
            )
        if target_x_out >= self.x:
            raise ValueError(
                "Rezervin tamamı çekilemez"
            )
        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) aralığında olmalıdır"
        )
    if cex_bids.is_empty():
        return {
            "opportunity": False,
            "reason": "CEX emir defteri boş"
        }
    best_bid = cex_bids.best_bid()
    if (
        best_bid *
        (1.0 - cex_fee)
        <=
        amm.spot_price()
    ):
        return {
            "opportunity": False,
            "reason": "Spread bulunmuyor"
        }
    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": "Likidite yetersiz"
        }
    if best_result["net_profit_usdt"] <= 0:
        return {
            "opportunity": False,
            "reason": "Slippage tüm kârı eritiyor"
        }
    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=== Arbitraj Arama Sonucu ===\n"
    )
    if not result["opportunity"]:
        print(
            f"Durum: İPTAL\n"
            f"Neden: {result['reason']}"
        )
        return
    print("Durum: FIRSAT BULUNDU")
    print()
    print(
        f"AMM Giriş: "
        f"${result['input_usdt_amm']:,.2f}"
    )
    print(
        f"Alınan ETH: "
        f"{result['bought_x']:.6f}"
    )
    print(
        f"CEX Brüt Gelir: "
        f"${result['gross_usdt_cex']:,.2f}"
    )
    print(
        f"CEX Net Gelir: "
        f"${result['net_usdt_cex']:,.2f}"
    )
    print(
        f"Net Kâr: "
        f"${result['net_profit_usdt']:,.2f}"
    )
    print(
        f"ROI: "
        f"{result['roi_pct']:.4f}%"
    )
    print(
        f"AMM Spot Fiyatı: "
        f"{result['amm_spot_price']:.4f}"
    )
    print(
        f"AMM Ort. Alış Fiyatı: "
        f"{result['amm_avg_buy_price']:.4f}"
    )
    print(
        f"AMM Fiyat Etkisi (Impact): "
        f"{result['amm_price_impact_pct']:.4f}%"
    )
    print(
        f"CEX VWAP: "
        f"{result['cex_vwap']:.4f}"
    )
if __name__ == "__main__":
    main()

8. Trader'lar İçin Çıkarılacak Dersler: «Cahillik Vergisi» Ödemekten Nasıl Kaçınılır?

Piyasa mikro yapısını anlamak akademik bir fantezi değil, bakiyenizi gizli sermaye kaçaklarından koruyan en temel silahtır.

• Piyasa koşullarına uygun emir tipleri kullanın: CEX üzerinde yüksek hacimli işlemler yaparken doğrudan «Market Order» girmek, emrinizin defterdeki kademeleri süpürmesine ve ciddi negatif slippage yemenize neden olur. Acil yürütme gerekiyorsa, kabul edebileceğiniz en kötü fiyatı belirterek IOC (Immediate-or-Cancel) veya FOK (Fill-or-Kill) emir türlerini tercih edin.
• Sadece spread'e değil, efektif derinliğe bakın: L2 ağlarında $0.01 seviyesindeki dar spread'ler genellikle bir ilüzyondur. Eğer en iyi Bid/Ask kademesinde sadece $100'lık likidite varsa, $50,000'lık emriniz defteri delip geçerek felaket bir ortalamayla gerçekleşir.
• AMM tarafındaki toksik akışı (toxic flow) hesaba katın: Önemli bir haber akışında veya yüksek volatilitede Uniswap v3 üzerinde dar bir bantta likidite sağlıyorsanız, HFT arbitrajcılarının doğrudan hedefi olursunuz. LVR (Loss-Versus-Rebalancing) metriği dakikalar içinde komisyon gelirinizi sıfırlar.
• DEX'te MEV korumasını aktif edin: AMM işlemlerinizde Slippage Tolerance parametresini her zaman sınırlayın (maksimum %0.1–0.3 arası tutun) veya işlemlerinizin genel mempool'a düşüp sandwich yememesi için Flashbots Protect / MEV-Blocker gibi özel RPC düğümlerini tercih edin.

Yorumlarda büyük emirler girerken en çok ne kadar kayma (slippage) yaşadığınızı ve günlük işlemlerinizde hangi modeli (CEX Order Book mu, DEX AMM mi) tercih ettiğinizi paylaşmayı unutmayın!