Order Book vs AMM: Mikrostruktur Pasar & Arbitrase HFT

Kalau sampai sekarang kamu masih mikir kalau transaksi di exchange itu cuma sekadar klik tombol "Buy" lalu keajaiban terjadi, siap-siap kaget. Di level mikrodetik dan milidetik, pasar itu adalah medan tempur yang sangat kejam. Likuiditas terus berpindah dari satu bentuk ke bentuk lain, sementara kecepatan eksekusi dan anatomi pool menentukan siapa yang bakal panen cuan dan siapa yang harus nanggung rugi akibat slippage serta toxic flow.

Di dunia trading tersentralisasi (TradFi dan CEX), Order Book adalah rajanya. Sementara di DeFi, AMM sudah jadi standar utama. Tapi ketika kita bedah di level High-Frequency Trading (HFT), perbedaan keduanya bukan cuma soal teknologi—tapi secara fundamental mengubah mekanika pembentukan harga, arbitrase, dan eksekusi order.

Yuk, kita bongkar bagaimana mekanika likuididad bekerja di balik layar dari kedua sistem ini, di mana letak hidden cost-nya, dan cara memanfaatkannya dalam praktik nyata.

1. Anatomi Order Book L2/L3: Seperti Apa Wujud Likuiditas Sebenarnya

Sebagian besar trader ritel cuma bisa melihat order book L2: akumulasi volume di setiap tingkatan harga. Tapi algoritma HFT dan pemain institusional bermain di level L3 (Order-by-Order)—aliran data mentah di mana setiap kejadian punya identitas unik (order_id), timestamp presisi tinggi, dan posisi pasti dalam antrean.

Prinsip Price-Time Priority (FIFO)

Dalam matching engine klasik, order dieksekusi secara ketat berdasarkan prioritas:

• Harga (harga terbaik selalu dapat prioritas utama).
• Waktu (jika harganya sama, yang masuk antrean lebih dulu yang dieksekusi).

Gara-gara sistem antrean berbasis waktu ini, muncul dua efek mikrostruktur yang sangat krusial:

Adverse Selection (Seleksi Merugi): Kalau limit order beli kamu tiba-tiba tereksekusi dengan sangat cepat, kemungkinan besar ada seller jumbo yang masuk membawa pesanan agresif (toxic flow), dan harga bakal terus merosot turun.

Queue Position Value: Posisi di barisan paling depan pada suatu tingkat harga punya nilai tersendiri. Bot HFT bakal terus-terusan melakukan cancel dan re-order (dengan trik Spoofing/Layering atau manajemen likuiditas adaptif) demi mempertahankan prioritas eksekusi tanpa perlu menanggung risiko simpanan aset (inventory risk) yang berlebihan.

2. AMM: Dari Constant Product Klasik ke Likuiditas Terkonsentrasi

Mekanisme AMM beda total dengan order book: di sini tidak ada yang namanya antrean order. Harga murni ditentukan oleh fungsi matematika invarian.

Constant Product (v2): x · y = k

Di Uniswap v2 klasik, likuididad tersebar merata dari nol sampai tak hingga.

Ketika ada transaksi sebesar Δx, trader mengambil sejumlah Δy dari pool, yang dihitung dengan memperhitungkan potongan fee γ = (1 - fee):

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

Harga eksekusi itu tidak pernah tetap, melainkan "tergelincir" di sepanjang kurva tepat saat eksekusi terjadi.

Concentrated Liquidity (v3 / Tick-based)

Uniswap v3 merombak AMM jadi mirip order book dengan mengizinkan Liquidity Provider (LP) menentukan rentang harga [P_a, P_b].

Harga dipecah menjadi tick, di mana setiap tick merepresentasikan pergeseran harga sebesar 0.01% (1 bps):

P(i) = 1.0001ⁱ

Likuiditas L di dalam rentang tersebut bekerja seperti invarian "virtual", tapi begitu melewati batas tick, likuiditas aktif bakal berubah secara drastis. Bagi pelaku arbitrase HFT, ini artinya satu hal: order book AMM v3 bersifat diskrit, dan kedalamannya berubah secara bertahap saat terjadi penembusan tick.

3. Analisis Komparatif: Microstructure Matrix

4. Mekanisme Tersembunyi: MEV, LVR, dan Toxic Flow

Di order book CEX, pemain HFT adu cepat memperebutkan nanodetik latensi jaringan fisik (colocation di data center exchange, kabel fiber optik, hingga chip FPGA).

Tapi di DeFi, konsep waktu bekerja secara unik: penyusunan blok adalah segalanya.

MEV (Maximal Extractable Value)

Dalam AMM, urutan transaksi di dalam blok diatur oleh Searcher dan Builder blok. Hal ini melahirkan taktik khas HFT:

• Front-running / Back-running: Meniup atau menyerobot transaksi di mempool dengan menyetor fee lebih tinggi (Priority Fee).
• Sandwich Attacks: Membeli aset tepat sebelum transaksi besar pengguna masuk untuk mendongkrak harga, lalu langsung menjualnya kembali tepat setelahnya.

LVR (Loss-Versus-Rebalancing)

Kebanyakan orang cuma memperhitungkan risiko LP dari Impermanent Loss (IL). Tapi di level trading frekuensi tinggi, metrik LVR yang dirumuskan oleh peneliti dari Columbia University dan Paradigm jauh lebih akurat.

LVR (Loss-Versus-Rebalancing) adalah kerugian sistematis yang dialami LP di AMM jika dibandingkan dengan portofolio yang sama yang terus di-rebalance secara berkala di CEX memakai referensi harga luar.

Penyebab utama LVR adalah arbitrase volatilitas. Saat harga di CEX melesat, harga di pool AMM bakal tertinggal (stale price). Arbitraseur HFT melihat selisih ini, langsung menyedot likuiditas murah dari AMM, dan mengamankan posisinya di CEX. Alhasil, LP di AMM selalu tereksekusi pada harga paling buntung saat berhadapan dengan alur transaksi yang terinformasi (toxic flow).

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

Di mana σ mewakili volatilitas aset, S_t adalah harga, dan L_t adalah likuiditas aktif. Kesimpulannya: Semakin liar volatilitas pasar, semakin banyak cuan LP yang disedot oleh pelaku arbitrase HFT.

5. Praktik: Skrip Python Hitung Kotasi AMM v3 vs Kedalaman L2

Sekarang saatnya masuk ke kodingan. Kita bakal bikin tool siap pakai buat menghitung harga eksekusi riil (yang sudah memperhitungkan slippage) untuk simulasi order, membandingkan kedalaman L2 order book dengan pool Constant Product AMM.

Kodenya dibuat pakai pure Python tanpa perlu dependensi library berat dari luar.

from __future__ import annotations
from dataclasses import dataclass
from enum import Enum
from typing import List
class FeeMode(Enum):
    QUOTE = "quote"  # fee dipotong dari USDT yang masuk
    BASE = "base"    # fee dipotong dari ETH yang diterima
@dataclass
class AskLevel:
    price: float
    volume: float
class OrderBookL2:
    """
    L2 Order Book (Sisi Ask).
    Contoh pair ETH/USDT:
        price  = USDT per 1 ETH
        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 harus berada dalam rentang [0, 1)")
        self.taker_fee = float(taker_fee)
        self.asks: List[AskLevel] = []
        for price, volume in asks:
            if price <= 0:
                raise ValueError("Harga harus > 0")
            if volume <= 0:
                raise ValueError("Volume harus > 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("Order book kosong")
        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]:
        """
        Pembelian aset dasar menggunakan amount_in_quote.
        Mengembalikan:
            (
                aset_dasar_yang_diterima,
                rata_rata_harga_efektif
            )
        """
        if amount_in_quote <= 0:
            raise ValueError(
                "amount_in_quote harus > 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(
                "Likuiditas di order book tidak mencukupi"
            )
        if fee_mode == FeeMode.BASE:
            total_base_bought *= (
                1.0 - self.taker_fee
            )
        if total_base_bought <= 0:
            raise ValueError(
                "Volume yang diterima bernilai nol"
            )
        avg_price = (
            amount_in_quote /
            total_base_bought
        )
        if mutate:
            self.asks = new_levels
        return total_base_bought, avg_price
class ConstantProductAMM:
    """
    Uniswap V2 style 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 harus > 0"
            )
        if reserve_y <= 0:
            raise ValueError(
                "reserve_y harus > 0"
            )
        if not (0 <= fee < 1):
            raise ValueError(
                "fee harus berada dalam rentang [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]:
        """
        Pembelian ETH menggunakan USDT.
        Mengembalikan:
            (
                ETH_yang_diterima,
                rata_rata_harga
            )
        """
        if amount_y_in <= 0:
            raise ValueError(
                "amount_y_in harus > 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(
                "Volume yang diterima bernilai nol"
            )
        if x_out >= self.x:
            raise ValueError(
                "Likuiditas di pool tidak mencukupi"
            )
        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" Diterima: {received:.6f}"
        f" | Harga Rata-rata: {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=== Perbandingan Eksekusi Order "
        f"sebesar {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=== Kondisi Setelah Transaksi ===\n")
    if orderbook.asks:
        print(
            f"Best Ask: "
            f"{orderbook.best_ask():,.4f}"
        )
    else:
        print("Order book ludes terjual")
    print(
        f"AMM Spot: "
        f"{amm.spot_price():,.4f}"
    )
    print(
        f"AMM Reserves: "
        f"{amm.x:.6f} ETH | "
        f"{amm.y:.2f} USDT"
    )
if __name__ == "__main__":
    main()

Cara Membaca Hasilnya

Di pool AMM yang tebal, order berskala kecil bakal tereksekusi dengan minim slippage. Tapi begitu volume transaksi membengkak, pergerakan harga di AMM bakal melonjak mengikuti kurva eksponensial. Sedangkan di order book, segalanya tergantung pada tembok likuiditas (liquidity walls). Kalau order book-nya tipis, transaksi bakal menyapu beberapa tingkatan harga sekaligus dan memicu lompatan harga yang jauh lebih parah ketimbang di AMM.

6. Model Hibrid: Bagaimanakah DEX Mengadopsi Order Book dan Mengapa CEX Mulai Melirik AMM?

Batas antara order book dan AMM makin ke sini makin samar. Para trader HFT dan institusi dengan cepat mentok saat menggunakan arsitektur klasik Uniswap v2: efisiensi modal yang minim serta absennya fitur limit order kompleks (seperti Stop-loss, Take-profit, hingga Iceberg) bikin DEX kurang bersahabat buat aktivitas market making skala besar.

Hal inilah yang memicu lompatan evolusi hingga lahir arsitektur hibrid.

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

Berkat kemunculan jaringan L1/L2 beperforma tinggi (seperti Aptos, Sui, Arbitrum) serta AppChain khusus, pengoperasian order book penuh secara langsung di atas blockchain kini bukan lagi sekadar wacana.

Off-chain matching + On-chain settlement: Modul pencocokan order (matching engine) berjalan di luar rantai menggunakan engine ultra-cepat (demi mengejar latensi < 10 ms), sedangkan mengeksekusi hasil settlement dan margin requirement tetap dikunci secara aman via smart contract.

Fully On-chain (Hyperliquid, Serum/Ellipsis): Seluruh mekanisme order book hidup sepenuhnya di dalam konsensus blockchain. Tantangan terbesarnya? Memproses beban transaksi yang amat masif: aktivitas pembatalan dan pembaruan order (Cancel/Replace) pada ranah HFT bisa menyedot hingga 95–98% dari total lalu lintas transaksi.

2. Arsitektur Berbasis Intent dan RFQ (Request for Quote)

Model "Intents" (Uniswap X, 1inch Fusion, CoW Protocol) secara praktis membawa kembali pendekatan eksekusi ala pemain institusional.

Di sini, trader tidak lagi menandatangani transaksi interaksi langsung ke liquidity pool tertentu, melainkan hanya menandatangani sebuah maksud/niat (misalnya: «Saya mau tukar 100 ETH ke minimal 300.000 USDC»). Selanjutnya, jaringan pihak ketiga (Filler / Solver) bakal saling sikut berebut hak mengeksekusi order tersebut dengan memanfaatkan sumber likuiditas mana pun — baik CEX, inventaris private market maker, maupun DEX.

Buat para trader di lapangan, mekanika ini menjamin zero slippage sekaligus kekebalan dari serangan sandwich MEV: seluruh risiko proskalizvaniya (slippage) dan eksekusi sepenuhnya ditanggung oleh Solver, yang mengeruk profit via arbitrase lintas aset.

7. Praktik: Skrip Arbitrase Tingkat Lanjut Antara CEX L2 Order Book dan AMM v2

Dalam dunia nyata, bot HFT secara nonstop memburu disparitas harga antara CEX dan AMM. Ketika harga suatu aset di CEX mendadak melonjak akibat lonjakan market buy, pool AMM bakal tertinggal sejenak dalam kondisi "stale" (usang). Arbitrageur akan mengeksekusi pembelian di AMM untuk mendorong harganya sejajar dengan CEX, lalu secara bersamaan melepas volume tersebut kembali ke CEX.

Di bawah ini adalah skrip Python siap pakai yang secara real-time mengalkulasi ukuran transaksi arbitrase paling optimal (dx) dengan mempertimbangkan fee AMM, kedalaman order book CEX, serta fee maker/taker.

from __future__ import annotations
from dataclasses import dataclass
from typing import List, Dict, Any
@dataclass
class BidLevel:
    price: float
    volume: float
class OrderBookSide:
    """
    Sisi Bid dari order book.
    price  = harga beli
    volume = volume aset dasar
    """
    def __init__(self, bids: List[tuple[float, float]]):
        self.bids: List[BidLevel] = []
        for price, volume in bids:
            if price <= 0:
                raise ValueError("Harga harus > 0")
            if volume <= 0:
                raise ValueError("Volume harus > 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("Order book kosong")
        return self.bids[0].price
    def cumulative_levels(self) -> List[tuple[float, float]]:
        """
        Mengembalikan titik-titik pergeseran likuiditas.
        [
            (2 ETH, VWAP hingga 2 ETH),
            (7 ETH, VWAP hingga 7 ETH),
            ...
        ]
        """
        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]:
        """
        Menjual amount_x ke dalam order book.
        Mengembalikan:
        (
            usdt_diterima,
            VWAP
        )
        """
        if amount_x <= 0:
            raise ValueError(
                "amount_x harus > 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(
                "Likuiditas order book tidak mencukupi"
            )
        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 harus > 0"
            )
        if reserve_y <= 0:
            raise ValueError(
                "reserve_y harus > 0"
            )
        if not (0 <= fee < 1):
            raise ValueError(
                "fee harus berada dalam rentang [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 harus > 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:
        """
        Inversi dari rumus AMM.
        Berapa USDT yang wajib dimasukkan
        untuk memperoleh target_x_out.
        """
        if target_x_out <= 0:
            raise ValueError(
                "target_x_out harus > 0"
            )
        if target_x_out >= self.x:
            raise ValueError(
                "Tidak bisa menguras seluruh cadangan"
            )
        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 harus berada dalam rentang [0,1)"
        )
    if cex_bids.is_empty():
        return {
            "opportunity": False,
            "reason": "Order book CEX kosong"
        }
    best_bid = cex_bids.best_bid()
    if (
        best_bid *
        (1.0 - cex_fee)
        <=
        amm.spot_price()
    ):
        return {
            "opportunity": False,
            "reason": "Tidak ada spread"
        }
    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": "Likuiditas tidak mencukupi"
        }
    if best_result["net_profit_usdt"] <= 0:
        return {
            "opportunity": False,
            "reason": "Slippage menggerus habis profit"
        }
    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=== Hasil Pencarian Arbitrase ===\n"
    )
    if not result["opportunity"]:
        print(
            f"Status: BATAL\n"
            f"Alasan: {result['reason']}"
        )
        return
    print("Status: PELUANG DITEMUKAN")
    print()
    print(
        f"Modal AMM: "
        f"${result['input_usdt_amm']:,.2f}"
    )
    print(
        f"ETH Dibeli: "
        f"{result['bought_x']:.6f}"
    )
    print(
        f"Pendapatan CEX: "
        f"${result['gross_usdt_cex']:,.2f}"
    )
    print(
        f"Pendapatan Bersih CEX: "
        f"${result['net_usdt_cex']:,.2f}"
    )
    print(
        f"Profit Bersih: "
        f"${result['net_profit_usdt']:,.2f}"
    )
    print(
        f"ROI: "
        f"{result['roi_pct']:.4f}%"
    )
    print(
        f"AMM Spot: "
        f"{result['amm_spot_price']:.4f}"
    )
    print(
        f"AMM Avg Buy: "
        f"{result['amm_avg_buy_price']:.4f}"
    )
    print(
        f"AMM Impact: "
        f"{result['amm_price_impact_pct']:.4f}%"
    )
    print(
        f"CEX VWAP: "
        f"{result['cex_vwap']:.4f}"
    )
if __name__ == "__main__":
    main()

8. Takeaway Praktis Buat Trader: Biar Nggak Kena «Pajak Kebodohan»

Paham mikrostruktur pasar itu bukan sekadar teori akademis yang bikin pusing. Ini adalah 'senjata' utama biar modal lu nggak 'bocor' halus gara-gara mekanisme teknis.

• Pilih jenis order sesuai kebutuhan pasar: Di CEX, kalau lu Hantam Kanan (Market Order) dengan volume gajah, eksekusinya dijamin bakal 'nembus' beberapa kedalaman order book sekaligus. Buntut-buntutnya dapet slippage parah. Kalau butuh eksekusi instan tanpa bonyok, pakai order jenis IOC (Immediate-or-Cancel) atau FOK (Fill-or-Kill) sambil matok batas harga terburuk yang masih sanggup lu toleransi.
• Ukur kedalaman efektif, jangan cuma tergiur spread tipis: Spread tipis di L2 (misal $0.01) sering kali cuma jebakan betmen. Kalau di Bid/Ask terbaik volumenya cuma $100, order $50.000 lu bakal langsung 'ngejebol' order book ke level bawah yang harganya udah beda jauh.
• Waspadai toxic flow saat jadi LP di AMM: Kalau lu memasok likuiditas di Uniswap v3 dengan rentang (range) ketat saat rilis berita penting atau kondisi pasar lagi 'berdarah-darah', lu cuma bakal jadi santapan empuk bot arbitrase HFT. Metrik LVR bakal melahap habis seluruh cuan dari fee transaksi cuma dalam hitungan menit.
• Pasang mode proteksi dari MEV di DEX: Tiap kali mau swap di AMM, selalu kunci Slippage Tolerance lu (maksimal di angka 0.1–0.3%) atau manfaatkan private RPC node (seperti Flashbots Protect / MEV-Blocker). Ini krusial biar transaksi lu nggak nyangkut di mempool publik yang bikin lu gampang dijadiin mangsa sandwich attack.

Boleh nih share di kolom komentar! Berapa persen slippage paling parah yang pernah lu alamin pas eksekusi order gede, dan model mana (CEX Order Book atau DEX AMM) yang jadi andalan lu buat trading harian?