无常损失：当 LP 到底亏不亏，把账算清楚

前面两篇文章，我们把”把币存进池子当 LP”这件事讲得热血沸腾：《Web3 金融的基石 - Swap 和 Staking》 用 x·y=k 从零搭了个池子，亲眼看着手续费一分一分进账；《当下流动性池分析》 又盘点了各家池子的设计，从 Uniswap V2 一路看到 Curve。看起来当 LP 就是”躺赚手续费”，稳得很。

但如果你真去当过 LP，大概率经历过这样的时刻：ETH 从 3000 涨到 6000，你打开钱包一看，仓位总价值确实涨了——可隔壁拿着币啥也不干的朋友，涨得比你多得多。你安慰自己”至少我还有手续费”，然后心里隐隐有个声音：我该不会……亏了吧？

这个声音有名字，叫无常损失（Impermanent Loss，IL）。先别急，别急着去搜定义，我们用一个摆摊的比喻把它钉在墙上：

你和朋友合伙摆摊。你出 1 个 ETH，朋友出 3000 USDT，凑成一份 6000 美元的货，放进摊子的收银台。这个摊子是程序控制的，脾气写死在代码里：只要价格一动，它就自动”卖掉涨得多的、收进跌得多的”。ETH 涨了？摊子根本不等你想，先把涨了的 ETH 卖给排队的客人；ETH 跌了？摊子反手往里收贬值的币。等你俩哪天散伙清点，把手里的东西折成钱，跟”当初不摆摊、俩人死拿着资产不动”比——总是少一截。

少的那一截，就是无常损失。

大部分文章讲到这里就跑路了，丢下一句”LP 会亏一点，手续费能补回来”就消失。本文不跑路：把手伸进 x·y=k 里，一笔一笔把账算到底，最后用 Python 验证每一个数字。读完后你应该能自己回答三个问题：亏多少？为什么叫”无常”？手续费什么时候填得平这个坑？

先回忆一下 x·y = k

老规矩，先把前置知识钉在墙上。AMM 池子就是那个收银台：两种币，储备量分别为 x 和 y，任何人 swap 时池子始终维持：

x · y = k（常数）

池内价格就是 y/x。有人买走 ETH（x 变小），y 就必须变大，价格随之上涨。画个重点：价格不是预言机报的，是这条乘积曲线自己”长”出来的——像跷跷板，一头下去另一头必然翘起来，支点的位置就是价格。完整推导和滑点原理在 《Web3 金融的基石 - Swap 和 Staking》 里，本文不重复，只需要记住两件事：

1. k 在 swap 中不变——摆摊的规矩，货柜两边的乘积恒等；
2. 池内价格只由储备比例决定——这恰恰是无常损失的祸根。

一笔具体的账：ETH 价格翻倍，LP 剩多少

还记得开头那个摊子吗？现在给它来一次压力测试：ETH 价格翻倍，散伙清点，看看到底少多少。下面每一步我都先说”现在要干嘛、为什么要算这一步”，你跟着走就行。

手推版

设定初始状态：你往一个 ETH/USDT 池子里存入 x₀ = 1 ETH 和 y₀ = 3000 USDT，此时池内价格 P₀ = 3000，恒定乘积 k = x₀ · y₀ = 3000。你占池子一定份额（假设你是唯一 LP，份额多少不影响百分比结论）。

第一步：外部价格翻倍。 现在要干嘛？先制造价差。某天，中心化交易所等外部市场的 ETH 价格涨到 P₁ = 6000，但你的池子没人动过，池内价格还是 3000。先别急，这不是坏事的开始——价差是套利者的血条，接下来发生的一切都由它驱动。

第二步：套利者搬平价差。 现在要干嘛？让池内价格追上外部价格——这一步是整篇故事的发动机，无常损失就是在这儿产生的。谁来干？套利者。他们冲进池子用 USDT 买走”便宜”的 ETH，一路买到池内价格等于外部价格 6000 才罢手。设套利后的储备为 x₁ 和 y₁，它们必须同时满足两条规矩：

y₁ / x₁ = 6000    （价格被搬平）
x₁ · y₁ = 3000    （k 不变）

为什么是两个方程？因为池子被买得再凶，规矩一条都不能破：价格得对上，乘积也得守住。两条方程、两个未知数，解是唯一的：

x₁ = √(3000/6000) = √0.5 ≈ 0.7071 ETH
y₁ = 3000 / 0.7071 ≈ 4242.64 USDT

翻译成人话：套利者从你的摊子上买走了约 0.2929 个 ETH。你一根手指都没动，摊子却替你做了决定——在上涨行情里自动卖 ETH，而且越涨越卖，永远在低位出货。这个画面请刻在脑子里，它是理解一切的钥匙。

第三步：清点摊子。 现在要干嘛？散伙清点，把摊子里的东西按新价格 6000 折成钱：

V_LP = 0.7071 × 6000 + 4242.64 ≈ 4242.64 + 4242.64 ≈ 8485.28 USDT

这里有个小彩蛋：两项居然相等。这不是巧合，x₁·P₁ = √(k/P₁)·P₁ = √(k·P₁) = y₁——乘积曲线天生对称，币那一半和钱那一半折成价值后一样多。第五节的通式推导会吃到这个红利。

第四步：拉一个对照组。 为什么要拉对照组？因为”亏不亏”得有参照系——跟谁比？跟当初不摆摊、死攥着原来的 1 ETH + 3000 USDT 不动的自己比：

V_HODL = 1 × 6000 + 3000 = 9000 USDT

第五步：差额结账：

V_LP − V_HODL = 8485.28 − 9000 = −514.72 USDT
IL = 8485.28 / 9000 − 1 ≈ −5.72%

画个重点，这里是最容易被误解的地方：LP 并没有亏绝对金额——投入的 6000 USDT 等值资产变成了 8485.28，涨了 41.4%，恭喜。但 HODL 党涨了 50%。无常损失是相对”拿着不动”的机会成本，不是账面亏损。市场涨了 50% 而你只涨了 41.4%，那 5.72% 就是 AMM 机制向你收的”过路费”。

代码验证

口算容易错，上代码。先说直觉：五步里真正干活的是第二步，套利搬平价差，数学上就是解一个二元方程。代码把这个方程封装成函数，任何价格倍数都能一秒出账单：

# 无常损失完整模拟：初始 1 ETH + 3000 USDT，价格翻倍
import math

def simulate_price_change(r: float):
    """外部价格变为原来的 r 倍后，套利者搬平价差，计算 LP 的账单"""
    x0, y0 = 1.0, 3000.0        # 初始储备：1 ETH + 3000 USDT
    p0 = y0 / x0                # 初始池内价格 3000
    k = x0 * y0                 # 恒定乘积 k = 3000
    p1 = p0 * r                 # 外部新价格

    # 套利后池内价格 = 外部价格：y1/x1 = p1 且 x1*y1 = k
    x1 = math.sqrt(k / p1)
    y1 = k / x1

    lp_value = x1 * p1 + y1         # LP 持仓价值（按新价格计价）
    hodl_value = x0 * p1 + y0       # 如果一直 HODL 的价值
    il = lp_value / hodl_value - 1  # 无常损失百分比
    return x1, y1, lp_value, hodl_value, il

# ---- 完整模拟：价格翻倍 ----
x0, y0, p0, k = 1.0, 3000.0, 3000.0, 3000.0
print(f"初始池子: {x0} ETH + {y0} USDT, k = {k}, 价格 {p0}")
x1, y1, lp_value, hodl_value, il = simulate_price_change(2.0)
print(f"套利后池子: {x1:.4f} ETH + {y1:.2f} USDT (k = {x1*y1:.2f})")
print(f"LP 持仓价值: {x1:.4f} x 6000 + {y1:.2f} = {lp_value:.2f} USDT")
print(f"HODL 价值:   1 x 6000 + 3000 = {hodl_value:.2f} USDT")
print(f"差额: {lp_value - hodl_value:.2f} USDT")
print(f"无常损失 IL: {il:.2%}")

运行结果：

初始池子: 1.0 ETH + 3000.0 USDT, k = 3000.0, 价格 3000.0
套利后池子: 0.7071 ETH + 4242.64 USDT (k = 3000.00)
LP 持仓价值: 0.7071 x 6000 + 4242.64 = 8485.28 USDT
HODL 价值:   1 x 6000 + 3000 = 9000.00 USDT
差额: -514.72 USDT
无常损失 IL: -5.72%

和手推的完全一致。读一下输出：池子里的 ETH 从 1 个掉到 0.7071 个，USDT 从 3000 涨到 4242.64，k 一分没变——被套利者搬走的 0.2929 个 ETH，就是你那 514.72 差额的实体形态。核心只有两行：x1 = sqrt(k / p1) 和 y1 = k / x1，套利过程被浓缩成解一个二元方程。这正是 AMM 的优雅（和残忍）之处：不需要任何人操纵，价差自己抹平自己，代价记在 LP 头上。

通用公式：IL = 2√r/(1+r) − 1

上面的数字太具体了。现在要干嘛？把代数做到底——把”3000””6000”这些死数字换成字母，让公式对任何币对、任何初始价格都成立。为什么值得做？因为只有炼出一个只跟”价格倍数”挂钩的公式，你才能不跑模拟器，心算出任何行情下的 IL。

设初始储备为 x₀、y₀，初始价格 P₀ = y₀/x₀，k = x₀·y₀。外部价格变为原来的 r 倍，即 P₁ = r·P₀。套利后池内价格等于 P₁，且乘积恒定——还是那两条规矩，还是那组方程，解出来：

x₁ = √(k / P₁)          y₁ = √(k · P₁)

接下来清点 LP 的家当。为什么敢直接写”两项相等”？用的是上一节那个彩蛋：乘积曲线对称，币的一半和钱的一半折成价值必然一样多，求出一份再乘 2 就行：

V_LP = x₁·P₁ + y₁
     = √(k/P₁)·P₁ + √(k·P₁)
     = √(k·P₁) + √(k·P₁)
     = 2·√(k·P₁) = 2·√(k·r·P₀) = 2·√(k·r)·√P₀

把 k = x₀²·P₀ 代进去化简——为什么要换这一步？因为 x₀²·P₀ 正好等于 x₀·y₀，代完之后所有带 x 的项都会被 y 收编，账面瞬间干净：

√(k·P₁) = √(x₀²·P₀·r·P₀) = x₀·P₀·√r = y₀·√r
所以：V_LP = 2·y₀·√r

对照组的 HODL 党也得按新价格折一遍，两条路才能比：

V_HODL = x₀·P₁ + y₀ = x₀·r·P₀ + x₀·P₀ = y₀·(1 + r)

最后一步，两者一比，你要的”亏多少”来了。你琢磨一下接下来会发生什么：y₀ 被干干净净地消掉了，池子多大、初始价格多少，统统不重要：

IL = V_LP / V_HODL − 1 = 2√r / (1 + r) − 1

验证一下：r = 2 时，IL = 2√2/3 − 1 ≈ 0.9428 − 1 = −5.72%，和模拟一致。这个公式美得过分——它只依赖价格倍数 r，跟池子大小、币种、初始价格统统无关。你存 1 个 ETH 还是 10000 个 ETH，结果一样。以后刷到任何”XX 涨了 N 倍”的新闻，N 一代，IL 秒出。

无常损失速查表

有了公式，把常用倍数全算出来。先别急着自己心算，开根号这种事交给代码，防止口算翻车：

# 无常损失速查表：IL = 2*sqrt(r)/(1+r) - 1（本块自包含，单独运行即可）
import math

print(f"{'价格变动':<14}{'r':>8}{'IL':>10}")
cases = [
    ("上涨 1.25 倍", 1.25), ("上涨 1.5 倍", 1.5), ("上涨 2 倍", 2.0),
    ("上涨 3 倍", 3.0), ("上涨 4 倍", 4.0), ("上涨 5 倍", 5.0),
    ("跌到 0.8 倍", 0.8), ("跌到 2/3 倍", 1/1.5), ("跌到 0.5 倍", 0.5),
    ("跌到 1/3 倍", 1/3), ("跌到 0.25 倍", 0.25), ("跌到 0.2 倍", 0.2),
]
for label, r in cases:
    il = 2 * math.sqrt(r) / (1 + r) - 1  # 闭式公式，与上面的模拟结果一致
    print(f"{label:<14}{r:>8.4f}{il:>10.2%}")

# 对称性验证：IL(r) 应该等于 IL(1/r)
print()
print("对称性验证 (IL(r) == IL(1/r)):")
for r in [1.25, 1.5, 2.0, 3.0, 4.0, 5.0]:
    il_up = 2 * math.sqrt(r) / (1 + r) - 1
    il_dn = 2 * math.sqrt(1/r) / (1 + 1/r) - 1
    print(f"  r={r:<5} 上涨 {il_up:.6%} | 下跌 {il_dn:.6%} | 相等: {math.isclose(il_up, il_dn)}")

运行结果：

价格变动                 r        IL
上涨 1.25 倍       1.2500    -0.62%
上涨 1.5 倍        1.5000    -2.02%
上涨 2 倍          2.0000    -5.72%
上涨 3 倍          3.0000   -13.40%
上涨 4 倍          4.0000   -20.00%
上涨 5 倍          5.0000   -25.46%
跌到 0.8 倍        0.8000    -0.62%
跌到 2/3 倍        0.6667    -2.02%
跌到 0.5 倍        0.5000    -5.72%
跌到 1/3 倍        0.3333   -13.40%
跌到 0.25 倍       0.2500   -20.00%
跌到 0.2 倍        0.2000   -25.46%

对称性验证 (IL(r) == IL(1/r)):
  r=1.25  上涨 -0.619201% | 下跌 -0.619201% | 相等: True
  r=1.5   上涨 -2.020410% | 下跌 -2.020410% | 相等: True
  r=2.0   上涨 -5.719096% | 下跌 -5.719096% | 相等: True
  r=3.0   上涨 -13.397460% | 下跌 -13.397460% | 相等: True
  r=4.0   上涨 -20.000000% | 下跌 -20.000000% | 相等: True
  r=5.0   上涨 -25.464401% | 下跌 -25.464401% | 相等: True

整理成速查表（四舍五入到 0.1%）——这张表建议截屏存手机，以后扫一眼就知道当 LP 要挨多少刀：

价格倍数 r	上涨情形 IL	对应的下跌情形（价格 ×1/r）IL
1.25	-0.6%	-0.6%
1.5	-2.0%	-2.0%
2	-5.7%	-5.7%
3	-13.4%	-13.4%
4	-20.0%	-20.0%
5	-25.5%	-25.5%

两个重要观察，画个重点：

• 对称性：涨 2 倍亏 5.7%，跌一半也亏 5.7%。IL(r) = IL(1/r) 可以从公式直接证明——把 1/r 代进 2√r/(1+r)，分子分母同乘 √r 就还原回来了。无常损失对方向不敏感，只对偏离幅度敏感——摊子不管行情是喜是悲，只在乎价格离原点有多远。
• 尾部惩罚很重：偏离 25% 只亏 0.6%，毛毛雨；偏离 4 倍就亏 20%，伤筋动骨。曲线在两端越跌越陡，说明 LP 真正的敌人不是日常波动，而是单边大行情。

把这条曲线画出来，形状很像一根下垂的香蕉——所以圈内叫它”香蕉图”：

为什么叫”无常”？

先别急着把这笔损失当成已到账的罚款。它是有条件的损失——账单挂在那里，但还没撕下来。

什么条件下会消失？价格回到原点。假设 ETH 从 6000 又跌回 3000（r 重新等于 1），套利者会沿着来路把储备再搬回去，IL 精确归零，仿佛什么都没发生过。”无常”（impermanent）说的就是这层含义：损失悬浮在那里，随时可以消失。

但悬着的账不是不报、时候未到——时候就是你撤池子的那一刻：

• 只要你在价格偏离时撤出，损失立刻被”结账”，从无常变成永久（permanent）。很多 LP 是在行情最疯狂时因为恐慌或收益计算而撤出的，恰好亲手把理论损失签字画押成实际亏损。
• 只要价格动过，币的构成就已经变了。 上涨时池子里的 ETH 被套利者陆续搬走，你手里涨幅最大的资产越来越少，收益天然封顶；下跌时反过来，套利者往摊子上塞贬值的币，你的仓位被动地”越跌越买”。有句圈内老话：LP 是在无脑自动执行”高抛低吸”的反义词——低抛高吸。

所以更准确的心理预期是：只要价格动过，LP 就已经被收了一次费，只是这笔费用悬浮着，等价格回来能退给你。手续费收入就是拿来覆盖这笔”过路费”的——这正是下一节的主题。

手续费填坑：和波动赛跑

回到摆摊。现在摊子的账本上有两栏：支出一栏是房租（无常损失，价格动过就挂账），收入一栏是流水（手续费，每一笔 swap 你都有分成）。LP 赚不赚钱，就看流水什么时候填平房租。

写成加减法（先忽略 gas 和流动性挖矿奖励）：

LP 净收益 ≈ 手续费分成 − 无常损失 IL

问题变成：一天流水多少，才够付清一次房租？流水厚不厚，取决于三个数：池子的费率、日交易量与 TVL 的比值（换手率，相当于摊子一天翻几次台）、以及你在池子里的份额。下面做个填坑模拟：0.3% 费率，假设我们只占池子 10% 的份额（一个普通用户在大池子里的真实处境），看看在换手率不同的情况下，多少天能赚回一次”价格翻倍”造成的 5.7% 无常损失：

# 手续费填坑模拟：0.3% 费率，多少天能赚回 5.7% 的 IL？（本块自包含，单独运行即可）
import math

fee_rate = 0.003          # 0.3% swap 费率
my_share = 0.10           # 假设我们占池子 10% 份额（大池子里小 LP 的真实处境）
il_double = 2 * math.sqrt(2.0) / (1 + 2.0) - 1  # 翻倍情形的 IL（与上面模拟一致）
target_il = abs(il_double)  # 需填平的 5.72%

print(f"费率: {fee_rate:.1%}，我占池子份额: {my_share:.0%}，需填平的 IL: {target_il:.2%}")
print(f"{'日交易量/TVL':>12}{'日收益率':>12}{'填平天数':>10}")
for ratio in [0.5, 1.0, 2.0, 5.0, 10.0]:
    # 日交易量 = ratio x 池子TVL；全池手续费 = 交易量 x 费率；我按 10% 份额分一块
    my_income = ratio * fee_rate * my_share   # 我的日手续费收入（按池子规模计）
    my_capital = my_share                     # 我的本金（按池子规模计）
    daily_yield = my_income / my_capital      # 相对自己本金的日收益率（份额会约掉！）
    days = target_il / daily_yield
    print(f"{ratio:>12.1f}{daily_yield:>12.4%}{days:>10.1f}")

# 对照：如果份额是 100%（独自做市一个小池子）
print()
print("对照组：独自做市（份额 100%）：")
for ratio in [0.5, 1.0, 2.0]:
    daily_yield = fee_rate * ratio * 1.0
    days = target_il / daily_yield
    print(f"  日交易量/TVL = {ratio:<4} 日收益率 {daily_yield:.4%} -> {days:.1f} 天填平 IL")

运行结果：

费率: 0.3%，我占池子份额: 10%，需填平的 IL: 5.72%
    日交易量/TVL        日收益率      填平天数
         0.5     0.1500%      38.1
         1.0     0.3000%      19.1
         2.0     0.6000%       9.5
         5.0     1.5000%       3.8
        10.0     3.0000%       1.9

对照组：独自做市（份额 100%）：
  日交易量/TVL = 0.5  日收益率 0.1500% -> 38.1 天填平 IL
  日交易量/TVL = 1.0  日收益率 0.3000% -> 19.1 天填平 IL
  日交易量/TVL = 2.0  日收益率 0.6000% -> 9.5 天填平 IL

这张表的信息量很大，画三个重点：

• 换手率是命根子。 日交易量只有 TVL 一半的冷清池子，相当于一家一天翻不满半轮台的馆子——填平一次翻倍的 IL 要 38 天，而行情可能一周就走完了。热门池子换手率可以到 5 倍甚至 10 倍，翻台如流水，填坑时间缩短到 4 天甚至 2 天，这才叫”手续费追上波动”。
• 份额不影响收益率百分比——对照主表和表尾的对照组，日收益率一模一样，只影响绝对金额。直觉在这行代码里：daily_yield = my_income / my_capital，你的收入按 10% 份额打折，你的本金也是 10% 份额，一约就没了——拿 10% 的摊位股分 10% 的流水，人均收益率和独资开店一样。
• 一个残酷的巧合：波动大的币对往往吸引更多交易量——IL 高的池子手续费也厚。LP 的本质就是站在这两股力量的交叉点上赌一个方向：流水跑赢房租，你就赢；反之，你就是给套利者打白工。

把填坑天数画成柱子，冷清和热门的差距一目了然：

V3 集中流动性：手续费效率与 IL 一起放大

上面所有推导都是 V2 的世界：你的钱均匀铺满 (0, ∞) 整个价格区间，绝大部分时间在”睡觉”。一句话直觉：Uniswap V3 就是让你把睡着的钱叫醒，圈进一个窄区间里上杠杆——比如你赌 ETH 在 2500–3500 之间晃，就把资金全押在这个区间，区间内的流动性密度可以是 V2 的几十倍，手续费效率暴涨。

但天下没有免费的午餐，杠杆放大的是分子也是分母：

• 手续费效率提升：区间内资金利用率高，同样 TVL 分到的手续费成倍增长。
• IL 也被放大：价格在区间内穿行时，你的币被以远比 V2 快的速度搬走；一旦价格跑出区间，仓位会变成 100% 单币——涨出上界，手里全是 USDT，完美错过后续涨幅；跌穿下界，手里全是 ETH，接盘接得明明白白。区间越窄，单位时间手续费越高，IL 的”结账速度”也越快。

V2 的 IL 是温水，V3 的 IL 是开水。想在 V3/V4 里做 LP，选区间本身就是一门手艺，这块 《Uniswap V4：更灵活、更高效的去中心化交易所》 讲了机制层面的演进，池子选型的横向对比则在 《当下流动性池分析》。

什么时候当 LP 是合理的

把本文的账变成一张决策清单，按”房租高低”从少到多排：

• 稳定币对（如 USDT/USDC）：价格几乎不动，r ≈ 1，IL 趋近于零——房租近乎为零，手续费几乎就是纯利润。这是最接近”躺赚”的池子，代价是收益率薄，而且要盯着脱锚风险（稳定币自己也出过事）。
• 波动小、长期横盘的主流币对：比如大市值币和稳定币的组合。日常 ±10% 的震荡对应 IL 不到 0.3%，手续费大概率覆盖得住。
• 有额外激励的池子：很多协议用治理代币补贴 LP，相当于商场给摊主发补贴。把激励折算成收益后一起算，如果 手续费 + 激励 > IL 预期，账才算得平。注意激励代币本身也常在暴跌，别把纸面年化当成真实收益。
• 暴涨暴跌的币对（尤其 meme 币）要慎入：价格偏离 4 倍就是 20% 的 IL，而手续费需要极高的换手率才能追上。多数人是在单边行情里被套利者反复收割的那一方。

免责声明：本文所有计算是教学简化（忽略 gas、滑点损耗、协议风险、激励代币波动等），不构成任何投资建议。真金白银入场前，请先用自己的仓位参数把本文的代码跑一遍。

总结

摊子收了，账本合上，核心结论就几行：

• 无常损失的本质：套利者利用 x·y=k 搬平内外价差，LP 被动执行”低抛高吸”，持仓价值永远跑输死拿不动的 HODL——摊子自动”卖掉涨得多的、收进跌得多的”，散伙清点总比死拿少一截。
• 通式：IL = 2√r/(1+r) − 1，只与价格倍数 r 有关。翻倍（或腰斩）亏 5.7%，4 倍偏离亏 20%，涨跌对称。
• “无常”的含义：价格回原点，账单作废；中途撤出，当场结账——不是不报、时候未到，时候就是你想走的那一天。
• 博弈：LP 净收益 ≈ 手续费 − IL。就是流水和房租的赛跑，胜负手是换手率（日交易量/TVL）：冷清池子填坑可能要一年，热门池子几十天。
• V3 集中流动性：把睡着的钱叫醒上杠杆，手续费效率和 IL 一起放大，价格跑出区间还会退化成单币仓位。

当 LP 不是”躺赚”，而是开了一家自动做市的店：赚的是过路费，赔的是存货错配。把账算清楚，再决定开不开店。

相关阅读

• 《Web3 金融的基石 - Swap 和 Staking》：x·y=k 的推导在这篇
• 《Uniswap V4：更灵活、更高效的去中心化交易所》：集中流动性如何放大资金效率
• 《当下流动性池分析》：各家池子设计对比；注意那篇 Bancor 段落里的 IL 公式是教学简化，本文的 2√r/(1+r)−1 才是标准公式
• 《加密交易的风险管理》：LP 也是一种仓位，同样要风控