mev-analysis

Solana DEX 交易的 MEV 分析

最大可提取价值（MEV）是验证者和搜索者通过在区块中重排、插入或审查交易所能获取的利润。在 Solana DEX 上，MEV 主要表现为针对兑换的三明治攻击、跨 DEX 套利和清算套利。本指南介绍检测、估算和防护策略。

Solana 上的 MEV 是什么？

当拥有交易排序权的人以其他交易者的损失获利时，就会发生 MEV。在 Solana 上，MEV 供应链的运作方式如下：

1. 你提交一笔兑换，通过 RPC 端点
2. 搜索者观察到你的交易（通过 RPC 转发、区块引擎访问或监听 Leader 的 TPU）
3. 搜索者构建一个有利可图的捆绑包（例如，对你的兑换发起三明治攻击）
4. 将捆绑包提交到 Jito 区块引擎，并向验证者支付小费
5. 验证者将捆绑包纳入区块，从而获得小费
6. 你的成交结果更差；搜索者则赚取差价

Solana MEV 与 Ethereum 的区别

方面	Ethereum	Solana
区块时间	12 秒	~400ms 时隙
内存池	公开内存池	没有内存池（但交易在传输过程中可见）
排序方式	提议者-构建者分离（PBS）	Jito 区块引擎（约 85% 以上的验证者）
捆绑包系统	Flashbots 捆绑包	带小费的 Jito 捆绑包
MEV 成本	Gas 优先费	Jito 小费（SOL）
延迟压力	中等	极高（决策时间低于 100ms）

Solana 特有的关键因素：

• 没有公开内存池：交易经由 RPC → TPU → Leader 流转，但搜索者会通过 Jito 的区块引擎和修改过的验证者接入这一流程
• 已知的 Leader 计划：Leader（区块生产者）计划提前约 2 个 epoch 就已知，因此搜索者可以针对特定 Leader 行动
• Jito 的主导地位：约 85% 以上的验证者运行 Jito 修改版客户端，因此 Jito 捆绑包是主要的 MEV 渠道
• 速度：400ms 的时隙意味着 MEV 机器人必须以微秒级速度运行，因此具备共置基础设施的一方更具优势

Solana 上的 MEV 类型

1. 三明治攻击

针对散户交易者最常见的 MEV 攻击。

运作方式：

1. Attacker sees your pending swap: Buy 10 SOL worth of TOKEN_X
2. Front-run:  Attacker buys TOKEN_X first  → price rises
3. Your swap:  You buy TOKEN_X at higher price → worse execution
4. Back-run:   Attacker sells TOKEN_X         → profits the difference

你的损失 = 抢跑导致的价格影响 + 攻击者的利润率 攻击者利润 = 你的损失 - jito 小费 - 交易手续费

风险因素：

• 交易规模：交易越大，发起三明治攻击的利润越高
• 代币流动性：流动性越低，越容易操纵价格
• 滑点设置：滑点越大，攻击者的操作空间越大
• 池类型：与集中范围内的 CLMM 池相比，CPMM 池更容易受到攻击

2. 套利（跨 DEX）

搜索者利用不同 DEX 之间的价格差异获利。

Pool A: TOKEN_X = 1.00 USDC
Pool B: TOKEN_X = 1.02 USDC
→ Buy on A, sell on B, profit 0.02 USDC per token (minus fees)

这通常对市场有益——它能使不同交易场所的价格趋于一致。不过，你的交易可能会触发搜索者捕捉到的套利机会。

3. 清算套利

当 DeFi 仓位（Solend、Marginfi、Kamino）抵押不足时，搜索者会竞相清算这些仓位并领取清算奖励（通常为 5%～10%）。

4. JIT（即时）流动性

搜索者在大额兑换前向 CLMM 池添加集中流动性，并在兑换后立即移除，从而赚取兑换手续费，同时避免持续暴露于无常损失。这是一种复杂的 MEV 形式，实际上可能改善兑换者的成交结果。

5. 跟跑交易

在推动价格变动的大额兑换后立即交易，以捕捉价格回归。与三明治攻击相比，这种方式危害较小，因为它不会使你的成交结果变差，而是从市场对你交易的反应中获利。

估算 MEV 风险敞口

执行交易前，先估算你的 MEV 风险：

import httpx

def estimate_mev_risk(
    trade_size_sol: float,
    pool_liquidity_usd: float,
    slippage_bps: int,
    token_daily_volume_usd: float,
) -> dict:
    """Estimate sandwich attack profitability for a given trade.

    Returns risk assessment with estimated cost and recommendations.
    """
    # Trade as percentage of pool liquidity
    sol_price = 150.0  # approximate; fetch live price in production
    trade_usd = trade_size_sol * sol_price
    trade_pct_of_pool = (trade_usd / pool_liquidity_usd) * 100

    # Estimated price impact from constant-product AMM
    # price_impact ≈ trade_size / pool_liquidity (simplified)
    price_impact_bps = int(trade_pct_of_pool * 100)

    # Sandwich profitability: attacker captures portion of slippage headroom
    # Rough model: sandwich_profit ≈ 0.5 * slippage_headroom * trade_size
    slippage_headroom_bps = slippage_bps - price_impact_bps
    if slippage_headroom_bps < 0:
        slippage_headroom_bps = 0

    sandwich_profit_usd = (slippage_headroom_bps / 10000) * trade_usd * 0.5
    jito_tip_cost = 0.001 * sol_price  # ~0.001 SOL typical tip
    tx_fees = 0.000015 * sol_price * 2  # two transactions for sandwich

    net_mev_profit = sandwich_profit_usd - jito_tip_cost - tx_fees
    is_profitable_to_sandwich = net_mev_profit > 0.10  # $0.10 minimum

    # Volume ratio indicates MEV bot attention level
    volume_ratio = trade_usd / max(token_daily_volume_usd, 1)

    risk_level = "LOW"
    if is_profitable_to_sandwich and trade_pct_of_pool > 1.0:
        risk_level = "HIGH"
    elif is_profitable_to_sandwich or trade_pct_of_pool > 0.5:
        risk_level = "MEDIUM"

    return {
        "risk_level": risk_level,
        "trade_pct_of_pool": round(trade_pct_of_pool, 2),
        "estimated_price_impact_bps": price_impact_bps,
        "slippage_headroom_bps": slippage_headroom_bps,
        "estimated_sandwich_cost_usd": round(max(net_mev_profit, 0), 2),
        "is_profitable_to_sandwich": is_profitable_to_sandwich,
        "recommendations": _get_recommendations(
            risk_level, trade_size_sol, slippage_bps, trade_pct_of_pool
        ),
    }


def _get_recommendations(
    risk_level: str,
    trade_size_sol: float,
    slippage_bps: int,
    trade_pct_of_pool: float,
) -> list[str]:
    """Generate protection recommendations based on risk assessment."""
    recs = []
    if risk_level == "HIGH":
        recs.append("Use Jito bundle with 0.001-0.005 SOL tip")
        recs.append("Use private/protected RPC endpoint")
    if trade_pct_of_pool > 2.0:
        n_splits = max(2, int(trade_pct_of_pool))
        recs.append(f"Split into {n_splits} trades over 2-5 minutes")
    if slippage_bps > 100:
        recs.append(f"Reduce slippage from {slippage_bps}bps to 50-100bps")
    if risk_level in ("MEDIUM", "HIGH"):
        recs.append("Enable Jupiter dynamic slippage / MEV protection")
    if not recs:
        recs.append("Standard execution is likely safe for this trade size")
    return recs

MEV 防护策略

策略 1：收紧滑点设置

将 slippageBps 设为可行的最低值。夹击攻击的利润受你的滑点容忍度限制。

代币流动性	建议滑点
> $5M 池	50 bps（0.5%）
$1M - $5M 池	100 bps（1%）
$100K - $1M 池	150-200 bps
< $100K 池	200-500 bps（高风险）

**权衡：**滑点设置过紧会导致交易失败，产生手续费却无法成交。

策略 2：Jito Bundle

将兑换作为带有优先费小费的 Jito bundle 提交：

import httpx

JITO_BLOCK_ENGINE = "https://mainnet.block-engine.jito.wtf"

async def submit_jito_bundle(
    signed_transactions: list[str],
    tip_lamports: int = 1_000_000,  # 0.001 SOL
) -> str:
    """Submit a transaction bundle to Jito block engine.

    Args:
        signed_transactions: Base64-encoded signed transactions.
        tip_lamports: Tip amount in lamports (1 SOL = 1e9 lamports).

    Returns:
        Bundle ID for tracking.
    """
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"{JITO_BLOCK_ENGINE}/api/v1/bundles",
            json={
                "jsonrpc": "2.0",
                "id": 1,
                "method": "sendBundle",
                "params": [signed_transactions],
            },
            timeout=10.0,
        )
        resp.raise_for_status()
        result = resp.json()
        return result.get("result", "")

小费指南：

• 普通优先级：0.0001 - 0.001 SOL
• 高优先级：0.001 - 0.01 SOL
• 紧急（市场波动剧烈）：0.01 - 0.05 SOL

策略 3：私有／受保护的 RPC

通过不会向搜索者暴露交易的端点发送交易：

• Jito bundles（如上所述）
• Helius priority fee API，使用质押连接
• QuickNode 私有交易提交
• 直接 TPU 转发（需要基础设施）

策略 4：拆分交易

对于大额交易（> 池流动性的 1%），拆分执行：

def compute_split_plan(
    total_sol: float,
    pool_liquidity_usd: float,
    sol_price: float = 150.0,
    max_pct_per_trade: float = 0.5,
) -> list[dict]:
    """Compute a trade splitting plan to minimize MEV exposure."""
    total_usd = total_sol * sol_price
    trade_pct = (total_usd / pool_liquidity_usd) * 100

    if trade_pct <= max_pct_per_trade:
        return [{"sol_amount": total_sol, "delay_seconds": 0}]

    n_splits = max(2, int(trade_pct / max_pct_per_trade) + 1)
    per_trade = total_sol / n_splits
    delay = 30  # seconds between trades

    return [
        {"sol_amount": round(per_trade, 4), "delay_seconds": i * delay}
        for i in range(n_splits)
    ]

策略 5：Jupiter MEV 保护

Jupiter v6 内置 MEV 保护功能：

• 动态滑点：自动调整滑点，以缩短夹击窗口
• 优先费估算：设置合适的计算单元价格
• 交易上链优化：通过逐步提高优先级的重试逻辑实现

通过 Jupiter API 启用：

params = {
    "inputMint": "So11111111111111111111111111111111111111112",
    "outputMint": token_mint,
    "amount": str(amount_lamports),
    "slippageBps": "50",
    "dynamicSlippage": "true",        # Auto-adjust slippage
    "prioritizationFeeLamports": "auto",  # Auto priority fee
}

检测夹击攻击

交易后，检查自己是否遭到夹击：

1. 获取你的交易并确定所在 slot
2. 获取该 slot 中涉及同一代币的所有交易
3. 查找以下模式：
   • 交易 A：买入 TOKEN_X（按 slot 排序，在你的交易之前）
   • 你的交易：买入 TOKEN_X（价格差于预期）
   • 交易 B：卖出 TOKEN_X（在你的交易之后，且与 A 使用相同的签名者）
4. 验证：A 和 B 的签名者是同一个钱包（攻击者）
5. 估算成本：你预期成交价与实际成交价之间的差额

查看 scripts/sandwich_detector.py，了解可运行的实现。

已知 MEV 指标：

• 交易签名者每天有数千笔交易
• 你的兑换前后，同一 slot 中出现针对同一代币的先买后卖交易
• 签名者频繁与 Jito tip 程序交互
• 钱包没有代币持仓（仅进行转入和转出）

与其他技能集成

• slippage-modeling：使用滑点估算来设置保护性限额
• liquidity-analysis：池流动性决定 MEV 风险
• jupiter-api：Jupiter 的 MEV 保护功能和兑换执行
• solana-onchain：链上交易分析，用于检测夹击攻击
• helius-api：交易解析和历史分析

文件

参考资料

• references/solana_mev_mechanics.md — Solana 区块生产、Jito 区块引擎、MEV 供应链和交易流路径
• references/protection_strategies.md — 详细的保护策略、实现指南、成本效益分析和决策矩阵

脚本

• scripts/sandwich_detector.py — 使用链上数据检测给定交易签名周围的夹击攻击
• scripts/mev_risk_estimator.py — 根据代币流动性、交易规模和滑点设置，估算计划交易的 MEV 风险