Order Book vs AMM: Microestrutura e Arbitragem HFT

Se você ainda acha que uma ordem na corretora é só clicar no botão "Buy" e esperar a mágica acontecer, tenho novidades pra você. No nível dos microssegundos e milissegundos, o mercado é uma zona de guerra brutal, onde a liquidez migra de um estado pra outro num piscar de olhos. A velocidade de execução e a anatomia da pool definem quem vai embolsar o lucro e quem vai pagar a conta do slippage e do fluxo tóxico.

No trading centralizado (TradFi e CEX), o Order Book é quem manda. No DeFi, o padrão da indústria virou o AMM. Mas quando a gente desce pro nível de alta frequência (HFT), a diferença entre eles vai muito além da tecnologia: ela muda radicalmente a dinâmica de formação de preço, arbitragem e execução de ordens.

Bora abrir o capô e entender como a mecânica de liquidez funciona de verdade em ambos os sistemas, onde estão os custos ocultos e como aplicar esse conhecimento na prática.

1. Anatomia do livro de ordens L2/L3: Como a liquidez realmente se parece

A maioria dos traders de varejo só enxerga o book L2: volumes agregados em cada nível de preço. Mas os algoritmos de HFT e os institucionais jogam no L3 (Order-by-Order) — um stream de dados brutos onde cada evento tem seu próprio ID único (order_id), carimbo de data/hora ultrapreciso e posição exata na fila.

O Princípio de Price-Time Priority (FIFO)

Em um matching engine clássico, as ordens são executadas seguindo uma hierarquia rígida:

• Preço (a melhor oferta sempre tem prioridade).
• Tempo (em caso de empate no preço, quem entrou na fila primeiro executa primeiro).

Essa fila por ordem de chegada gera dois efeitos cruciais na microestrutura de mercado:

Adverse Selection (Seleção Adversa): Se a sua ordem limite de compra é executada rápido demais, há uma grande chance de que um grande vendedor entrou rasgando a mercado com um fluxo agressivo (toxic flow), e o preço vai continuar desabando.

Queue Position Value: Estar na frente da fila em um determinado nível de preço tem valor financeiro próprio. Os bots de HFT vivem cancelando e reencaminhando ordens (táticas de Spoofing/Layering ou gestão adaptativa de liquidez) só para manter o topo da fila sem assumir risco desnecessário de inventário.

2. AMM: Do clássico Constant Product à Liquidez Concentrada

O AMM é totalmente diferente de um livro de ordens: não existe fila. O preço é cravado por uma função matemática invariante.

Constant Product (v2): x · y = k

No Uniswap v2 tradicional, a liquidez fica espalhada do zero ao infinito.

Quando um trader manda a ordem pra comprar um volume de Δx, ele drena do pool uma quantia de Δy, calculada já descontando a taxa γ = (1 - fee):

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

O preço de execução não é fixo; ele "desliza" ao longo da curva no exato momento da execução.

Concentrated Liquidity (v3 / Baseada em Ticks)

O Uniswap v3 aproximou o AMM de um order book ao permitir que os provedores de liquidez (LPs) escolham intervalos customizados [P_a, P_b].

O preço é fatiado em ticks, onde cada variação de tick representa uma mudança de 0.01% (1 bps):

P(i) = 1.0001ⁱ

A liquidez L dentro da faixa opera como uma invariante "virtual", mas quando o preço cruza a fronteira do tick, a liquidez ativa muda de soco. Para o arbitrador de alta frequência, isso significa que o book do AMM v3 é discreto e sua profundidade varia em degraus conforme os ticks são rompidos.

3. Análise Comparativa: Matriz de Microestrutura

4. Mecânicas Ocultas: MEV, LVR e Toxic Flow

No livro de ordens de uma CEX, a galera do HFT briga por nanossegundos de latência física (colocation no data center da exchange, cabos de fibra dedicada, placas FPGA).

No DeFi, o conceito de tempo é distorcido: a regra do jogo é quem consegue estruturar o bloco.

MEV (Maximal Extractable Value)

Nos AMMs, a ordem das transações dentro de um bloco é orquestrada por Searchers e Builders. Isso dá origem a dinâmicas clássicas de HFT no ecossistema cripto:

• Front-running / Back-running: Furar a fila de transações na mempool oferecendo uma taxa de prioridade maior (Priority Fee).
• Sandwich Attacks: Comprar logo antes de uma ordem grande de um usuário para inflar o preço e despejar na cara dele imediatamente no mesmo bloco.

LVR (Loss-Versus-Rebalancing)

Todo mundo se acostumou a calcular o risco de LP usando Impermanent Loss (IL). Só que pro HFT, a métrica que importa de verdade é o LVR, conceito formulado por pesquisadores da Universidade de Columbia e da Paradigm.

LVR (Loss-Versus-Rebalancing) é o prejuízo sistemático que um provedor de liquidez no AMM amarga em comparação com um portfólio idêntico que é rebalanceado continuamente numa CEX usando preços externos.

A causa raiz do LVR é a arbitragem de volatilidade. Quando o preço na CEX anda, o pool de AMM fica para trás mostrando um preço desatualizado (stale price). O bot de arbitragem detecta esse spread, drena a liquidez barata do AMM e se desfaz dela na CEX. O LP do AMM sempre toma a pior ponta da operação contra um fluxo informado (toxic flow).

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

Onde σ é a volatilidade do ativo, S_t é o preço e L_t é a liquidez ativa. Moral da história: Quanto maior a volatilidade do mercado, mais dinheiro os LPs entregam de bandeja pros arbitradores de HFT.

5. Mão na massa: Script Python para cotação em AMM v3 vs Profundidade L2

Hora do código. Vamos construir uma ferramenta funcional em Python para calcular o preço real de execução (contando com o slippage) para uma ordem hipotética, comparando a profundidade de um book L2 contra uma pool AMM Constant Product.

Tudo feito em Python puro, sem firula e sem dependências pesadas.

from __future__ import annotations
from dataclasses import dataclass
from enum import Enum
from typing import List
class FeeMode(Enum):
    QUOTE = "quote"  # taxa descontada do USDT que entra
    BASE = "base"    # taxa descontada do ETH recebido
@dataclass
class AskLevel:
    price: float
    volume: float
class OrderBookL2:
    """
    Livro de ordens L2 (Lado dos Asks).
    Exemplo do par ETH/USDT:
        price  = USDT por 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 deve estar no intervalo [0, 1)")
        self.taker_fee = float(taker_fee)
        self.asks: List[AskLevel] = []
        for price, volume in asks:
            if price <= 0:
                raise ValueError("O preço deve ser > 0")
            if volume <= 0:
                raise ValueError("O volume deve ser > 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("O livro de ordens está vazio")
        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]:
        """
        Simula a compra do ativo base usando amount_in_quote.
        Retorna:
            (
                ativo_base_recebido,
                preco_medio_efetivo
            )
        """
        if amount_in_quote <= 0:
            raise ValueError(
                "amount_in_quote deve ser > 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(
                "Liquidez insuficiente no livro de ordens"
            )
        if fee_mode == FeeMode.BASE:
            total_base_bought *= (
                1.0 - self.taker_fee
            )
        if total_base_bought <= 0:
            raise ValueError(
                "Volume recebido foi zero"
            )
        avg_price = (
            amount_in_quote /
            total_base_bought
        )
        if mutate:
            self.asks = new_levels
        return total_base_bought, avg_price
class ConstantProductAMM:
    """
    AMM no estilo Uniswap V2
    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 deve ser > 0"
            )
        if reserve_y <= 0:
            raise ValueError(
                "reserve_y deve ser > 0"
            )
        if not (0 <= fee < 1):
            raise ValueError(
                "fee deve estar no intervalo [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]:
        """
        Simula a compra de ETH usando USDT.
        Retorna:
            (
                ETH_recebido,
                preco_medio
            )
        """
        if amount_y_in <= 0:
            raise ValueError(
                "amount_y_in deve ser > 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 recebido foi zero"
            )
        if x_out >= self.x:
            raise ValueError(
                "Liquidez insuficiente na pool"
            )
        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" Recebido: {received:.6f}"
        f" | Preço Médio: {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=== Comparação de Execução de Ordem "
        f"de {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=== Estado Pós-Trade ===\n")
    if orderbook.asks:
        print(
            f"Best Ask: "
            f"{orderbook.best_ask():,.4f}"
        )
    else:
        print("Livro de ordens totalmente limpado")
    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()

Como interpretar os resultados

Em pools profundas de AMM, ordens pequenas executam com slippage quase nulo, mas conforme o volume escala, o preço no AMM sobe em uma curva convexa bem acentuada. Já no livro de ordens, tudo depende das muralhas de liquidez (liquidity walls). Se o book estiver ralo, você vai rasgar vários níveis de preço de uma vez e tomar uma cacetada de slippage muito pior do que no AMM.

6. Modelos Híbridos: Como DEXs estão adotando Order Books e por que CEXs de olho no AMM

A linha que separa livros de ofertas e AMMs está cada vez mais tênue. Traders de alta frequência (HFT) e institucionais rapidamente bateram no teto do que o Uniswap v2 clássico podia entregar: baixa eficiência de capital e a impossibilidade de pendurar ordens limite complexas (Stop-loss, Take-profit, Iceberg) tornavam as DEXs inviáveis para um market making pesado.

Isso provocou um salto evolutivo, dando origem às arquiteturas híbridas.

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

Com a chegada de redes L1/L2 de altíssimo throughput (Aptos, Sui, Arbitrum) e AppChains dedicadas, rodar um order book completo direto na blockchain virou realidade.

Off-chain matching + On-chain settlement: A engine de casamento de ordens roda fora da rede em motores ultra-rápidos (buscando latências < 10 ms), enquanto a liquidação final e os requisitos de margem são travados via smart contracts.

Fully On-chain (Hyperliquid, Serum/Ellipsis): O livro de ofertas roda 100% no consenso da blockchain. O grande gargalo aqui é aguentar o volume insano de operações: o fluxo de alteração e cancelamento de ordens (Cancel/Replace) no HFT representa de 95% a 98% de todas as transações de entrada.

2. Arquitetura Baseada em Intenções (Intent-Based) e RFQ (Request for Quote)

O modelo de "Intents" (Uniswap X, 1inch Fusion, CoW Protocol) na prática resgata a abordagem institucional de execução de ordens.

Em vez de assinar uma transação interagindo direto com uma pool específica, o trader assina uma intenção (ex.: «Quero trocar 100 ETH por no mínimo 300.000 USDC»). A partir daí, uma rede de executores terceirizados (Fillers / Solvers) briga para ver quem entrega a melhor execução, buscando liquidez onde for preciso — CEXs, inventário privado de market makers ou DEXs.

Para quem está boletando no dia a dia, isso significa slippage zero e blindagem total contra sandwich attacks de MEV: todo o risco de derrapagem e execução fica nas costas do Solver, que se remunera via arbitragem cross-asset.

7. Na Prática: Script Avançado de Arbitragem entre CEX L2 Order Book e AMM v2

No jogo real, bots de HFT vivem caçando desalinhamento de preço entre CEX e AMM. Quando o preço de um ativo dispara na CEX por conta de uma boletada a mercado, a pool do AMM fica "defasada" (stale) por alguns instantes. O arbitrador então compra no AMM empurrando o preço até nivelar com a CEX, descarregando o volume comprado de volta na CEX.

Abaixo está um script em Python pronto para rodar, que calcula em tempo real o tamanho ideal da mão na arbitragem (dx), levando em conta a taxa do AMM, a profundidade do livro da CEX e as taxas de 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:
    """
    Lado de Bid (compra) do livro de ofertas.
    price  = preço de compra
    volume = volume do ativo base
    """
    def __init__(self, bids: List[tuple[float, float]]):
        self.bids: List[BidLevel] = []
        for price, volume in bids:
            if price <= 0:
                raise ValueError("O preço deve ser > 0")
            if volume <= 0:
                raise ValueError("O volume deve ser > 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("O livro de ofertas está vazio")
        return self.bids[0].price
    def cumulative_levels(self) -> List[tuple[float, float]]:
        """
        Retorna os pontos de inflexão da liquidez.
        [
            (2 ETH, VWAP até 2 ETH),
            (7 ETH, VWAP até 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]:
        """
        Venda de amount_x agredindo o livro.
        Retorna:
        (
            USDT_recebido,
            VWAP
        )
        """
        if amount_x <= 0:
            raise ValueError(
                "amount_x deve ser > 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(
                "Liquidez insuficiente no livro de ofertas"
            )
        vwap = received_y / amount_x
        return received_y, vwap
class AMMPool:
    """
    Constant Product AMM (x * y = k)
    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 deve ser > 0"
            )
        if reserve_y <= 0:
            raise ValueError(
                "reserve_y deve ser > 0"
            )
        if not (0 <= fee < 1):
            raise ValueError(
                "a taxa deve estar no intervalo [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 deve ser > 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:
        """
        Inversa da fórmula do AMM.
        Quanto USDT precisa entrar
        para drenar target_x_out.
        """
        if target_x_out <= 0:
            raise ValueError(
                "target_x_out deve ser > 0"
            )
        if target_x_out >= self.x:
            raise ValueError(
                "Impossível drenar 100% da reserva"
            )
        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 deve estar no intervalo [0,1)"
        )
    if cex_bids.is_empty():
        return {
            "opportunity": False,
            "reason": "Livro da CEX vazio"
        }
    best_bid = cex_bids.best_bid()
    if (
        best_bid *
        (1.0 - cex_fee)
        <=
        amm.spot_price()
    ):
        return {
            "opportunity": False,
            "reason": "Sem spread operacional"
        }
    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": "Liquidez insuficiente"
        }
    if best_result["net_profit_usdt"] <= 0:
        return {
            "opportunity": False,
            "reason": "Slippage corroeu o lucro"
        }
    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=== Resultado da Análise de Arbitragem ===\n"
    )
    if not result["opportunity"]:
        print(
            f"Status: CANCELADO\n"
            f"Motivo: {result['reason']}"
        )
        return
    print("Status: OPORTUNIDADE ENCONTRADA")
    print()
    print(
        f"Entrada no AMM: "
        f"${result['input_usdt_amm']:,.2f}"
    )
    print(
        f"ETH Comprado: "
        f"{result['bought_x']:.6f}"
    )
    print(
        f"Receita Bruta CEX: "
        f"${result['gross_usdt_cex']:,.2f}"
    )
    print(
        f"Receita Líquida CEX: "
        f"${result['net_usdt_cex']:,.2f}"
    )
    print(
        f"Lucro Líquido: "
        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"Preço Médio Compra AMM: "
        f"{result['amm_avg_buy_price']:.4f}"
    )
    print(
        f"Impacto de Preço AMM: "
        f"{result['amm_price_impact_pct']:.4f}%"
    )
    print(
        f"CEX VWAP: "
        f"{result['cex_vwap']:.4f}"
    )
if __name__ == "__main__":
    main()

8. Takeaways para o Trader: Como Não Pagar a "Taxa da Ignorância"

Entender microestrutura de mercado não é só teoria acadêmica. É a ferramenta que vai impedir seu capital de escorrer pelo ralo no dia a dia.

• Ajuste o tipo de ordem para o momento do mercado: Em CEXs, mandar uma ordem a mercado (Market Order) pesada vai varrer vários níveis do livro com certeza, te entregando uma derrapagem dolorosa. Se precisar de execução imediata, use ordens IOC (Immediate-or-Cancel) ou FOK (Fill-or-Kill) cravando o pior preço aceitável.
• Olhe a profundidade real, não só o spread: Um spread espremido no L2 ($0.01) muitas vezes é ilusão de ótica. Se no top do book (Bid/Ask) só tem $100 de liquidez, uma ordem sua de $50.000 vai rasgar o livro até camadas com preços bizarros.
• Cuidado com o fluxo tóxico nos AMMs: Se você provê liquidez no Uniswap v3 em um range estreito durante o payroll ou um pico de volatilidade, vira presa fácil para bots de HFT. O tal do LVR (Loss-Versus-Rebalancing) vai engolir todas as suas taxas cobradas em questão de minutos.
• Proteja-se de MEV em DEXs: Em swaps via AMM, nunca deixe o parâmetro de Slippage Tolerance aberto (mantenha entre 0.1% e 0.3% no máximo) ou use RPCs privadas (como Flashbots Protect / MEV-Blocker) para evitar que sua transação fique dando bobeira na mempool pública esperando um sandwich attack.

Manda nos comentários: qual é a maior derrapagem que você já tomou executando boleta grande? E no dia a dia, qual é o seu porto seguro: Order Book na CEX ou AMM na DEX?