Uniswap V2 解读（一）

用户91184491294
0 阅读17分钟

Uniswap 是以太坊上最知名的去中心化交易所（DEX），首创 AMM 自动做市商模式，不靠订单簿，依靠「流动性池 + 恒定乘积公式 x⋅y=kx\cdot y=k」实现代币自动兑换。

恒定乘积自动做市商公式

英文 constant product automarket maker 即 AMM

x⋅y=kx \cdot y = k

  • kk 是恒定的值，即流动性
  • xx 表示要换出的代币token的数量
  • yy 表示要换入的代币token的数量 这个 kk 在交换的时候是不变的

一个用户想要卖出 dxdx 的 token，用 x+dxx + dx 来表示。对于xx 来讲相当于用户把 dxdx 数量的代币注入到 xx 池子中 一个用户想要买入 dydy 的 token，用 y−dyy - dy 来表示。对于yy 来讲相当于用户把 dydy 数量的代币从 yy 池子中取出 因为要保持恒定值 kk 不变，所以 (x−dx)⋅(y+dy)=k=x⋅y(x-dx) \cdot (y+dy) = k = x \cdot y

案例：

假定一个交易对 ETH / USDT，10 ETH <==> 20000 USDT，那么流动性 kk = 10 × 20000 = 200000

① 用户卖出5个ETH (10+5)⋅(20000−dy)=20000(10 + 5) \cdot (20000 - dy) = 20000

得： dy=20000−20000015=666.67Udy=20000-\frac{200000}{15}=666.67U

② 用户持有 10000U10000U，想买入ETH

(10−dx)⋅(20000+10000)=200000(10-dx)\cdot (20000+10000)=200000

得：dx=10−20000030000=3.33Edx=10-\frac{200000}{30000}=3.33E

③ 有1个疯子持有10万个ETH，能换多少个USDT？这10万个ETH能卖出吗？

(10+100000)⋅(20000−dy)=20000(10 + 100000) \cdot (20000 - dy) = 20000

得：dy=20000−200000100010=19998.00002Udy=20000-\frac{200000}{100010}=19998.00002U

即：可以卖出，得到的 UU 会无限接近 UU 池的总数 20000

结论 这个公式可以支撑token在任何价格上的买卖，也体现了价格是由市场决定的

价格问题

由上面的案例可以看到一个问题。

在交易开始时：

ETH 和 USDT 兑换的初始价格是：1个ETH 兑换 2000 USDT

px=yx=2000010=2000U/ETHp_x=\frac{y}{x}=\frac{20000}{10}=2000 U/ETH

USDT 和 ETH 兑换的初始价格是： 2000 个ETH 兑换 1 USDT

py=xy=1020000=0.005ETH/Up_y=\frac{x}{y}=\frac{10}{20000}=0.005ETH/U

然后可以看到上面的案例，真实交易的结果是亏了，我们把这个情况称做为滑点，之所以出现这个情况是因为池子太浅，假如是使用 0.001ETH来兑换USDT，这时的滑点和预期价格一致

滑点（Slippage）

定义：下单时看到的预期价格 ≠ 订单实际成交价格，两者之间的差价，就叫滑点。

通俗理解：你点击下单那一刻的行情，等指令传到市场，价格已经动了，成交价“滑走了”。

滑点（Slippage）=执行价格−预期价格预期价格⋅100%滑点（Slippage） = \frac{执行价格 - 预期价格}{预期价格} \cdot 100\%

两种滑点

1）负滑点（最常见、对你不利）

✅ 做多（买入）：预期100，实际成交 100.5 → 买贵了

✅ 做空（卖出）：预期100，实际成交 99.5 → 卖便宜了

2）正滑点（对你有利，比较少见）

✅ 做多：预期100，实际 99.7，买到更低价

✅ 做空：预期100，实际 100.4，卖出更高价

注意：止损单触发后会变成市价单，极易出现滑点！ 行情跳空时，你的止损价位直接被跳过，会在更远价位成交。

滑点为什么会发生？

  1. 流动性不足（最重要） 买卖挂单少，你大单进场，当前价位承接盘不够，只能逐级寻找下一档价格成交。冷门品种、深夜交易滑点普遍更大。
  2. 行情剧烈波动（数据、突发消息、开盘跳空） 价格毫秒级跳动，订单还没送达交易所，价格已经变动。
  3. 网络/服务器延迟
  4. 市价单机制：市价单追求立刻成交，不锁死价格，天然自带滑点风险； 👉 限价单可以锁定价格，不会产生滑点，但有可能无法成交。

流动性（Liquidity）

有很多地方讲流动性的公式并不是用的 x⋅y=kx\cdot y=k，而是使用的x⋅y=L\sqrt{x\cdot y} = L

x⋅y=k=L2x \cdot y = k = L^2

为什么要开根号❓ 比如 x和y 的单位是米，那么 kk 的单位就是 m2m^2，即 kk 是一个指数的关系，为了表示一个线性的关系，所以需要对 kk 开根号

对于任何一个交易对 流动性提供者，叫 Liquidity Provider (LP)

LP给的凭证叫 Liquidity Provider Token （LPT）

初始流动性

决定了token价格

添加流动性

要求：添加流动性时不能影响市场价格 x+dxy+dy=xy\frac{x+dx}{y+dy}=\frac{x}{y}

移除流动性

同样也不可以影响价格 x−dxy−dy=xy\frac{x-dx}{y-dy}=\frac{x}{y}

操作ETHUSDTETH池总币数USDT池总币数ETH 兑换 USDT
的比例		备注概念要点
初始流动性5.0010000.005100002000初始流动性：决定了TOKEN的价格
添加流动性5.0010000.0010200002000① 要保持系数不变添加流动性：不可以影响价格
第一笔交易15.00-6666.672513333.33533.3332
移除流动性-12.50-6666.6712.56666.665533.3332① 要保持系数不变
② 因为添加流动性时，
占用的正好是初始流动性的一半
所以移出的ETH：ETH=252=12.5ETH=\frac{25}{2}=12.5		移除流动性：不可以影响价格
项目方跑路了，把币池给撤了，就是指移除了流动性

UniswapV2

包含的模块以及关键的合约如下：

  • V2-core模块：UniswapV2Pair.sol、UniswapV2Factory.sol
  • V2-pheriphery模块：UniswapV2Router02.sol

路由合约

github.com/Uniswap/v2-…

关键函数：

  • 我有确定的代币数量要换，使用swapExactTokensForTokens
  • 我知道想要换出多少代币，但不我不知道要用多少来换，使用swapTokensForExactTokens
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external virtual override ensure(deadline) returns (uint[] memory amounts) {
        amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path);
        require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
        TransferHelper.safeTransferFrom(
            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
        );
        _swap(amounts, path, to);
    }
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external virtual override ensure(deadline) returns (uint[] memory amounts) {
        amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
        require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
        TransferHelper.safeTransferFrom(
            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
        );
        _swap(amounts, path, to);
    }

案例

案例1：DAI / USDT 交换

flowchart LR
    User[&#34;👤 用户&#34;]
    Router[&#34;Router02.sol&#34;]
    Pair[&#34;Pair<br/>DAI/USDT&#34;]
    
    User --&#34;① swapExactTokensForTokens<br/>swapTokensForExactTokens&#34; --> Router
    Router --&#34;② transferFrom&#34;--> Pair
    Router --> Pair
    Pair --&#34;③ swap(内部执行兑换计算) &#34;--> Pair
    Pair --&#34;④ transfer&#34; --> User

案例2：DAI / MKR 交换，但是没有DAI 直接交换 MKR的路径，需要经过多跳才能转换: DAI -> USDT -> MKR

flowchart LR
    User[&#34;👤 用户&#34;]
    Router[&#34;Router02.sol&#34;]
    Pair1[&#34;Pair1<br/>DAI/USDT&#34;]
    Pair2[&#34;Pair2<br/>USDT/MKR&#34;]
    
    User --&#34;① swapExactTokensForTokens(path=[DAI,USDT,MKR])&#34;--> Router
    Router --&#34;② transferFrom DAI 用户→Pair1 &#34;--> Pair1
    Router --> Pair1
    Pair1 --&#34;③ swap 内部计算 DAI→USDT&#34;--> Pair1
    Pair1 --&#34;.中转USDT.&#34;--> Pair2
    Router --> Pair2
    Pair2 --&#34;④ swap 内部计算 USDT→MKR&#34;--> Pair2
    Pair2 --&#34;⑤ transfer MKR&#34;--> User

	// given an output amount of an asset and pair reserves, returns a required input amount of the other asset
	function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
        require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
        amounts = new uint[](path.length);
        amounts[amounts.length - 1] = amountOut;
        for (uint i = path.length - 1; i > 0; i--) {
            (uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
            amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
        }
    }

每次执行 swap 交易都会产生一笔手续费，因此普通用户通常倾向选择兑换路径最短的交易路由。但套利机器人有所不同，一旦监测到多个交易池之间存在价差失衡，即便路径更长，也会采用多跳路由完成套利。

以swapExactTokensForTokens 为例，参数详解（UniswapV2Router02） 功能：确定输入代币数量，换取尽可能多的输出代币 路径示例：path = [DAI, USDT, MKR]，用固定数量 DAI 兑换 MKR

function swapExactTokensForTokens(
    uint amountIn,
    uint amountOutMin,
    address[] calldata path,
    address to,
    uint deadline
) external virtual override ensure(deadline) returns (uint[] memory amounts)
  • uint amountIn你愿意付出的确切代币数量
  • uint amountOutMin最少能接受拿到多少目标代币（滑点保护）

例：预期收到 990 MKR，设置 amountOutMin = 980 * 1e18 - 如果行情波动，最终能兑换到的代币 < amountOutMin → 交易直接回滚，不成交 - 作用：抵御套利、币价剧烈波动，防止滑点亏太多

  • address[] calldata path**兑换路径数组，决定多跳路由** 示例 [DAI, USDT, MKR]` 规则：

    • path[0] = 付出的代币
    • path[path.length-1] = 最终收到的代币
    • 数组相邻两个地址构成一个 Pair： DAI+USDT 为第一池，USDT+MKR 第二池
    • Router 自动循环 path，串联多个 Pair 完成多跳交换

  • address to` 最终兑换出来的代币转给谁

  • uint deadline**交易有效截止时间戳（秒，unix时间）** 搭配修饰器 ensure(deadline)` 逻辑：

如果区块执行时间 ≥ deadline → revert 拒绝执行 典型用法：block.timestamp + 600（10分钟有效期） 防止长时间挂单，行情大变后被动成交。

github.com/Uniswap/v2-…

	// given an output amount of an asset and pair reserves, returns a required input amount of the other asset
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
        require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
        require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
        uint numerator = reserveIn.mul(amountOut).mul(1000);
        uint denominator = reserveOut.sub(amountOut).mul(997);
        amountIn = (numerator / denominator).add(1);
    }
    // given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
        require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
        require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
        uint amountInWithFee = amountIn.mul(997);
        uint numerator = amountInWithFee.mul(reserveOut);
        uint denominator = reserveIn.mul(1000).add(amountInWithFee);
        amountOut = numerator / denominator;
    }

理解997、1000这些魔法数字的含义：

公式推导

(x0+dx)⋅(y0−dy)=x0y0(x_0+dx)\cdot(y_0-dy) = x_0 y_0

  • reserveIn = x0x_0（输入代币储备）
  • reserveOut = y0y_0（输出代币储备）
  • amountOut = dydy（想要拿到的输出数量）
  • amountIn = dxdx（需要付出的输入数量）
(x0+dx)⋅(y0−dy)=x0y0(x_0+dx)\cdot(y_0-dy) = x_0 y_0推导出dydy等于多少❓
getAmountOut		推导出dxdx等于多少❓
getAmountIn
展开左侧乘积x0⋅y0−x0⋅dy+y0⋅dx−dx⋅dy=x0⋅y0x_0\cdot y_0 - x_0\cdot dy + y_0\cdot dx - dx\cdot dy = x_0\cdot y_0
两边消去 x0y0x_0 y_0−x0⋅dy+y0⋅dx−dx⋅dy=0- x_0\cdot dy + y_0\cdot dx - dx\cdot dy = 0
移项y0⋅dx=x0⋅dy+dx⋅dyy_0\cdot dx = x_0\cdot dy + dx\cdot dyx0⋅dy=y0⋅dx−dy⋅dxx_0\cdot dy = y_0\cdot dx - dy\cdot dx
右侧提取公因子 dydy
y0⋅dx=dy⋅(x0+dx)y_0\cdot dx = dy\cdot (x_0 + dx)		右侧提取公因子 dxdx
x0⋅dy=dx⋅(y0−dy) x_0\cdot dy = dx\cdot (y_0 - dy)
两边同除以 (x0+dx)(x_0+dx)
dy=y0⋅dxx0+dx\boldsymbol{dy = \frac{y_0\cdot dx}{x_0 + dx}}		两边除以 (y0−dy)(y_0-dy)
dx=x0⋅dyy0−dy\boldsymbol{dx=\frac{x_0 \cdot dy}{y_0 - dy}}
因为还需要考虑到收取手续费的情况dy=y0⋅(1−f)⋅dxx0+(1−f)⋅dx\boldsymbol{dy = \frac{y_0\cdot (1-f)\cdot dx}{x_0 + (1-f)\cdot dx}}(1−f)⋅dx=x0⋅dyy0−dy\boldsymbol{(1 - f) \cdot dx=\frac{x_0 \cdot dy}{y_0 - dy}}
dx=x0⋅dyy0−dy⋅11−f\boldsymbol{dx=\frac{x_0 \cdot dy}{y_0 - dy} \cdot \frac{1}{1 - f }}
手续费是千3，即 0.3%0.3\%dy=y0⋅0.997⋅dxx0+0.997⋅dx \boldsymbol{dy = \frac{y_0\cdot 0.997\cdot dx}{x_0 + 0.997\cdot dx}}dx=x0⋅dyy0−dy⋅10.997\boldsymbol{dx=\frac{x_0 \cdot dy}{y_0 - dy} \cdot \frac{1}{ 0.997 }}
因为计算我们不考虑小数dy=y0⋅0.997⋅dxx0+0.997⋅dx⋅10001000 \boldsymbol{dy = \frac{y_0\cdot 0.997\cdot dx}{x_0 + 0.997\cdot dx} \cdot \frac{1000}{1000}}dx=x0⋅dyy0−dy⋅1000997\boldsymbol{dx=\frac{x_0 \cdot dy}{y_0 - dy} \cdot \frac{1000}{ 997 }}
结果dy=997⋅dx⋅y01000⋅x0+997⋅dx \boldsymbol{dy = \frac{997\cdot dx\cdot y_0}{1000\cdot x_0 + 997\cdot dx}}dx=1000⋅x0⋅dy997⋅(y0−dy)\boldsymbol{dx=\frac{1000 \cdot x_0 \cdot dy}{997 \cdot (y_0 - dy)}}

补充关键细节 getAmountIn 代码末尾 .add(1)

amountIn = (numerator / denominator).add(1);

这是整数向上取整：Solidity 除法是向下取整，+1 保证实际输入数量足够拿到目标 amountOut，避免精度不足导致交易失败。

Swap之下的手续费增长

Uniswap V2：为什么持续 Swap 会让池子流动性（储备）持续增长

无手续费理想AMM（理论模型） (x+dx)(y−dy)=xy(x+dx)(y-dy)=xy 交易完成后 kk 不变，池子总代币价值不变。 单纯交易，池子资产不会增加。

Uniswap V2（0.3%交易手续费模型） 用户转入全部输入代币 dxdx 进池子； 但合约只用 0.997⋅dx0.997\cdot dx 参与恒定乘积公式计算兑换数量： (x+0.997dx)⋅(y−dy)=xy(x + 0.997dx)\cdot(y - dy) = xy 交易结束后池子新储备：

x′=x+dxx' = x + dx

y′=y−dyy' = y - dy

差额 0.003⋅dx0.003\cdot dx，也就是0.3%手续费，直接留在池子里，不发给任何人。

于是： x′y′>xy,k↑x'y' > xy,\quad k \uparrow

✅ 结论： 每一笔swap，都会有一部分代币以手续费形式沉淀在池中。 不断有人交易，储备 x(x、y)yx(x、y)y 持续累积，池子总资产持续上涨。

这里说的“流动性增长”≠有人添加流动性（addLiquidity）。 不需要LP充币，仅靠用户反复swap，池子储备本身就能内生增长。

案例： 初始池子：DAI 100 / USDT 100 普通交易者用 DAI 兑换 USDT，池内储备变为 DAI 104、USDT 96.77，池子价格失衡； 套利机器人捕捉价差机会，快速执行反向交易，最终池内储备回归 DAI 101 / USDT 101，价格重新恢复均衡。

Pasted image 20260818081112.png

  1. 套利机器人的作用：修复 AMM 池子价格 普通交易者的单笔大额 swap 会打破(xy=k)形成的市场价格；套利机器人捕捉价格偏离，通过反向交易抹平滑点，让池子价格和外部市场保持一致。
  2. 收益来源 机器人低买高卖：在 DAI 相对便宜的时候买入 DAI，完成一轮操作后赚取差额利润。

关键约束：套利毛利必须覆盖 swap 手续费与 gas 成本，否则机器人不会启动。

如何让 LP （流动性提供者）受益于手续费

每一笔交易产生的手续费不会单独发放，直接留在池子中，让池内代币总量不断增加。 LP 代币总数量不变，因此每一枚 LP 凭证能兑换到的代币持续变多。LP 想要拿到手续费收益，只能销毁 LP 代币、撤出流动性赎回资产，增量部分就是手续费收益。 LP 向交易池注入代币获得 LP 凭证；交易手续费持续沉淀在池内抬高资产总值，最终 LP 撤出流动性时，取回包含本金与手续费的代币。

作为Uniswap项目方是如何受益的

Uniswap项目方会收取 protocol fee（协议费），是从 0.3% 交易手续费 里切分出一部分给项目方。

  • 关闭协议费（feeTo = 0）：0.3%全部归属LP；
  • 开启协议费（配置feeTo接收地址）：约定比例分给协议方，剩余归LP。 V2硬编码比例：协议费占总手续费的1/6。 也就是总费率0.3%：

协议费：0.3%×16=0.05%0.3\% \times \dfrac{1}{6} = 0.05\% LP获得：0.3%×56=0.25%0.3\% \times \dfrac{5}{6} = 0.25\%

关键设计：协议费不在swap时直接转账 和LP手续费一样，swap产生的手续费先全部留在池子储备里，抬高K值。 只有触发 mint（添加流动性） / burn（移除流动性） 的瞬间，合约才会计算K的增量，铸造新的LP代币发给feeTo地址。

协议费不随每笔swap实时扣费，依靠K值增长核算；仅在增减流动性时铸造LP分给项目地址。项目方想要兑现收益，同样需要销毁收到的LP代币提取池内资产。

协议费从0.3%交易手续费中划分0.05%，手续费先存入池子推高K；仅当用户添加或移除流动性时，合约自动铸造LP代币分配给项目方地址，项目方赎回LP完成收益兑现。

Pasted image 20260818104243.png

SmS_m的计算公式推导： 已知等式： SmSm+S1=ϕ(k2−k1)k2 \frac{S_m}{S_m+S_1} = \frac{\phi\left(\sqrt{k_2}-\sqrt{k_1}\right)}{\sqrt{k_2}}

交叉相乘 Sm⋅k2=ϕ(k2−k1)⋅(Sm+S1)S_m \cdot \sqrt{k_2} = \phi(\sqrt{k_2}-\sqrt{k_1})\cdot(S_m + S_1)

展开右侧 Smk2=ϕ(k2−k1)Sm+ϕ(k2−k1)S1S_m\sqrt{k_2} = \phi(\sqrt{k_2}-\sqrt{k_1}) S_m + \phi(\sqrt{k_2}-\sqrt{k_1}) S_1

把含 SmS_m 项移到左边 Smk2−Sm⋅ϕ(k2−k1)=ϕ(k2−k1)S1S_m\sqrt{k_2} - S_m\cdot\phi(\sqrt{k_2}-\sqrt{k_1}) = \phi(\sqrt{k_2}-\sqrt{k_1}) S_1

Sm[k2−ϕ(k2−k1)]=S1ϕ(k2−k1)S_m \Big[\sqrt{k_2} - \phi(\sqrt{k_2}-\sqrt{k_1})\Big] = S_1\phi(\sqrt{k_2}-\sqrt{k_1})

整理得到通式 Sm=S1⋅ϕ(k2−k1)k2−ϕ(k2−k1)\boldsymbol{S_m = S_1 \cdot \frac{\phi(\sqrt{k_2}-\sqrt{k_1})}{\sqrt{k_2}-\phi(\sqrt{k_2}-\sqrt{k_1})}}

带入 Uniswap V2 标准条件

V2协议费固定：ϕ=16\boldsymbol{\phi=\dfrac{1}{6}} Sm=S1⋅16(k2−k1)k2−16(k2−k1)=S1⋅k2−k15k2+k1S_m = S_1\cdot \frac{\dfrac{1}{6}(\sqrt{k_2}-\sqrt{k_1})}{\sqrt{k_2}-\dfrac{1}{6}(\sqrt{k_2}-\sqrt{k_1})} = \color{red}{S_1\cdot\frac{\sqrt{k_2}-\sqrt{k_1}}{5\sqrt{k_2}+\sqrt{k_1}}}

当涨幅不大时近似（工程常用简化）

k2≈k1\sqrt{k_2}\approx\sqrt{k_1}，可以近似： Sm≈S1⋅16(k2k1−1)S_m \approx S_1\cdot \frac{1}{6}\left(\frac{\sqrt{k_2}}{\sqrt{k_1}}-1\right) 也就是常看到的教科书简化公式。

  • k2−k1\sqrt{k_2}-\sqrt{k_1}：蛋糕新增增量（也就是常说的把蛋糕做大的含义）
  • ϕ\phi：约定从增量里抽取的比例（V2为1/6）
  • 等式意义： 新铸造份额 SmS_m 占铸造后总份额(S1+Sm)(S_1+S_m) 的比例 = 协议方分得价值占新蛋糕k2\sqrt{k_2} 的比例

核心思想：协议方不是切旧蛋糕，只瓜分池子膨胀出来的新增部分；铸造SmS_m之后稀释全体LP，但稀释来源仅仅是手续费带来的资产增量。

Uniswap V2 白皮书 app.uniswap.org/whitepaper.…

【2.4 Protocol fee】

添加流动性

Pasted image 20260818114200.png 池子储备 (x,y)(x,y)，流动性公式定义：L=x⋅y\boldsymbol{L = \sqrt{x\cdot y}}

同一条双曲线 xy=k →L=kxy=k\ → L=\sqrt{k} 固定不变。

也就是说在(x0,y0)(x_0,y_0) 这个时刻，流动性 L0=x0y0L_0=\sqrt {x_0y_0}，而L1L_1【即是(x0+dx,y0+dy)(x_0+dx,y_0+dy)的流动性】为 L1=(x0+dx)(y0+dy)L_1=\sqrt{(x_0+dx)(y_0+dy)}

理清概念：

  • LP Token 是流动性Token，是链上ERC20代币载体

  • LP Share 是流动性份额，代表你占整个池子总流动性的所有权比例 你的份额比例=你拥有的Share数量池子全部Share总量\text{你的份额比例} = \frac{\text{你拥有的Share数量}}{\text{池子全部Share总量}}

  • 它是抽象权益：代表你将来赎回时，可以按比例瓜分池子里所有 x,y 资产；

  • 数学公式里我们写的 Sm、S0S_m、S_0，全部指 LP Share。 类比： LP Share（S）= 持有的公司股份 LP Token = 记录你持有多少股份的股权证书（ERC20 代币） 举个例子 公司总共发行 100 份股权凭证（LP Token 总量 = 100） 你手里持有 10 枚 LP Token → 你拥有 10% LP Share（10% 股份）

  • 池子资产价值 1000U，你理论可赎回价值 100U；

  • 一天手续费赚 50U，你分到 5U。

所以用户新增流动性SS，应该的计算公式： L1−L0L0=ST\frac{L_1-L_0}{L_0}=\frac{S}{T}

  • L0L_0：增资前池子总流动性 L0=x0y0L_0=\sqrt{x_0 y_0}
  • L1L_1：用户投入资产后的新总流动性 L1=(x0+dx)(y0+dy)L_1=\sqrt{(x_0+dx)(y_0+dy)}
  • L1−L0L_1-L_0：用户新增带来的流动性增量
  • TT：增资前 LP Token 总发行量 totalSupply（原有全部股份总和）
  • SS：用户本次新增、将要铸造得到的 LP Token（新股份）

等式文字翻译：新增流动性占原有流动性的比例 = 用户新拿到的LP份额 ÷ 池子原先全部LP总份额 新增流动性原有总流动性=新铸造给你的LP池子原本所有LP总量\frac{\text{新增流动性}}{\text{原有总流动性}}=\frac{\text{新铸造给你的LP}}{\text{池子原本所有LP总量}}

池子 = 公司

L0L_0 = 公司当前总资产体量

TT = 公司已经发行的全部股票

用户增资注入资产，让公司体量涨到 L1L_1

ΔL=L1−L0\Delta L=L_1-L_0 = 用户新投入对应的资产体量

规则：你投入资产占原有公司体量的比值 = 你获得新股占原有总股本的比值

举例： L0=100, L1=120L_0=100,\ L_1=120，原有总股本 (T=1000)(T=1000) 120−100100=S1000⇒20100=S1000⇒S=200\frac{120-100}{100}=\frac{S}{1000} \Rightarrow \frac{20}{100}=\frac{S}{1000}\Rightarrow S=200

  • 公司原来100体量，1000股；
  • 你带来20体量资产；
  • 给你新发 200股。 增资之后： 总股本变为 (T+S=1200)(T+S=1200) 你持股比例：2001200=16\dfrac{200}{1200}=\dfrac{1}{6}

⚠️ 重要提醒： ST\dfrac{S}{T} 不是你最终持股比例！ 最终持股比例是 ST+S\boldsymbol{\dfrac{S}{T+S}} 公式只是用来计算本次应该铸造多少新LP。

💡 S=T⋅L1−L0L0\boldsymbol{S = T\cdot \frac{L_1-L_0}{L_0}}

因为：L0=x0y0, L1=(x0+dx)(y0+dy)L_0=\sqrt{x_0 y_0},\ L_1=\sqrt{(x_0+dx)(y_0+dy)}

S=T⋅(x0+dx)(y0+dy)−x0y0x0y0\boldsymbol{S = T\cdot \frac{\sqrt{(x_0+dx)(y_0+dy)}-\sqrt{x_0 y_0}}{\sqrt{x_0 y_0}}}

因为：dxx0=dyy0=r\dfrac{dx}{x_0}=\dfrac{dy}{y_0}=r，r 是放大倍数。

所以设： dx=r⋅x0dx = r\cdot x_0 dy=r⋅y0dy = r\cdot y_0

带放上面的公式

S=T⋅(x0+dx)(y0+dy)−x0y0x0y0\boldsymbol{S = T\cdot \frac{\sqrt{(x_0+dx)(y_0+dy)}-\sqrt{x_0 y_0}}{\sqrt{x_0 y_0}}}

=T⋅(x0+r⋅x0)(y0+r⋅y0)−x0y0x0y0=\boldsymbol{T \cdot \frac{\sqrt{(x_0+r\cdot x_0)(y_0+r\cdot y_0)}-\sqrt{x_0 y_0}}{\sqrt{x_0y_0}}}

=T⋅(x0(1+r)⋅y0(1+r)−x0y0x0y0=\boldsymbol{T \cdot \frac{\sqrt{(x_0(1+r)\cdot y_0(1+r)}-\sqrt{x_0 y_0}}{\sqrt{x_0y_0}}}

=T⋅(x0⋅y0)⋅(1+r)2−x0y0x0y0\boldsymbol{= T\cdot \frac{\sqrt{(x_0\cdot y_0)} \cdot \sqrt{(1+r)^2}-\sqrt{x_0 y_0}}{\sqrt{x_0 y_0}}}

=T⋅(x0⋅y0)⋅(1+r)−x0⋅y0x0⋅y0\boldsymbol{= T\cdot \frac{\sqrt{(x_0\cdot y_0)} \cdot (1+r)-\sqrt{x_0\cdot y_0}}{\sqrt{x_0\cdot y_0}}}

因为：L0=x0⋅y0L_0=\sqrt {x_0\cdot y_0}

=T⋅L0⋅(1+r)−L0L0\boldsymbol{= T\cdot \frac{L_0\cdot (1+r)-L_0}{L_0}}

=T⋅L0⋅rL0\boldsymbol{= T\cdot \frac{L_0\cdot r}{L_0}}

=T⋅r\boldsymbol{= T\cdot r}

前面定义了 r=dxx0=dyy0r=\frac{dx}{x_0}=\frac{dy}{y_0}

所以最终得到公式，即用户本次添加流动性，合约新铸造、发放给用户的 LP Token 数量：

S=T⋅(x0+dx)(y0+dy)−x0y0x0y0=T⋅dxx0=T⋅dyy0\boldsymbol{S = T\cdot \frac{\sqrt{(x_0+dx)(y_0+dy)}-\sqrt{x_0 y_0}}{\sqrt{x_0 y_0}}=\color{red}{T\cdot \frac{dx}{x_0}=T\cdot \frac{dy}{y_0}}}

理论上：T⋅dxx0=T⋅dyy0T\cdot \frac{dx}{x_0}=T\cdot \frac{dy}{y_0}

但是在合约计算中，会存在精度的丢失。所以在合约代码中会写成 S=min(T⋅dxx0,T⋅dyy0)\color{red}{S=min(T\cdot \frac{dx}{x0},T\cdot \frac{dy}{y0})}

Uniswap V2 里添加流动性的实现

flowchart LR
    User[&#34;👤 用户&#34;]
    Router[&#34;UniswapV2 Router&#34;]
    Factory[&#34;UniswapV2 Factory&#34;]
    Pair[&#34;DAI/WETH Pair 池子&#34;]

    %% 1. 用户发起添加流动性
    User -- &#34;1.addLiquidity&#34; --> Router
    %% 2. Router 查询/请求创建交易对
    Router -- &#34;2.getPair / createPair&#34; --> Factory
    %% 3. Factory 使用CREATE2部署Pair（首次创建才执行）
    Factory -- &#34;3.CREATE2 部署Pair合约&#34; --> Pair
    %% 4. 转账用户代币到池子
    User -- &#34;4.transferFrom(DAI/WETH)&#34; --> Pair
    %% 5. Router调用Pair铸币
    Router -- &#34;5. mint()&#34; --> Pair
    %% 6. Pair把新铸造的LP Token转给用户
    Pair -- &#34;6.transfer LP Token&#34; --> User

Step1： 用户调用 addLiquidity（发起交易） 用户钱包发起交易，调用 UniswapV2Router02.addLiquidity(tokenA, tokenB, amountA, amountB,...)

用户想要存入 DAI + WETH，提供流动性，换取 LP Token。 用户不会直接调用 Pair 合约，全部走 Router 做中转。

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external virtual override ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
        (amountA, amountB) = _addLiquidity(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin);
        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
        TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA);
        TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB);
        liquidity = IUniswapV2Pair(pair).mint(to);
    }

    // **** ADD LIQUIDITY ****
    function _addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin
    ) internal virtual returns (uint amountA, uint amountB) {
        // create the pair if it doesn't exist yet
        if (IUniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)) {
            IUniswapV2Factory(factory).createPair(tokenA, tokenB);
        }
        (uint reserveA, uint reserveB) = UniswapV2Library.getReserves(factory, tokenA, tokenB);
        // 省略..........
    }

Step2：Router 调用 Factory：getPair / createPair Router 先去 Factory 查询：DAI-WETH 这个交易对是否已经存在

  • ✅ 已有 Pair：直接拿到 Pair 合约地址，继续下一步
  • ❌ 不存在 Pair：触发创建逻辑，执行 Step 3

Step3：Factory 通过 CREATE2 部署全新 Pair 合约 Uniswap V2 使用 CREATE2 部署 Pair， 好处：交易对地址可以离线预先算出，不需要上链查询。 部署成功后 Factory 会记录：(tokenA,tokenB) → pairAddress 的映射关系。

只有第一次创建交易对时，才会执行 Step 3；后续再加流动性直接跳过 Step 3。

Step4：transferFrom：把用户的代币转到 Pair 池子 Router 触发 token.transferFrom(用户地址, Pair地址, 数量) 前提：用户提前授权（approve） Router 操作自己的 DAI/WETH。 执行完成：用户钱包里的 DAI、WETH，转入 DAI/WETH Pair 合约内部，成为池子储备 x,y。

Step 5：Router 调用 Pair 的 mint() 铸币函数

    // this low-level function should be called from a contract which performs important safety checks
    function mint(address to) external lock returns (uint liquidity) {
        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
        uint balance0 = IERC20(token0).balanceOf(address(this));
        uint balance1 = IERC20(token1).balanceOf(address(this));
        uint amount0 = balance0.sub(_reserve0);
        uint amount1 = balance1.sub(_reserve1);

        bool feeOn = _mintFee(_reserve0, _reserve1);
        uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
        if (_totalSupply == 0) {
            liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
           _mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
        } else {
            liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
        }
        require(liquidity > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED');
        _mint(to, liquidity);

        _update(balance0, balance1, _reserve0, _reserve1);
        if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
        emit Mint(msg.sender, amount0, amount1);
    }

这里就是前面推导出来的公式：

liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);

S=min(T⋅dxx0,T⋅dyy0)\color{red}{S=min(T\cdot \frac{dx}{x0},T\cdot \frac{dy}{y0})} mint

是最关键一步！ Pair 合约拿到新增的两种代币后：

  1. 读取池子旧储备量 x0,y0
  2. 计算本次应该铸造多少 LP Token（就是公式里的 S）
  3. 内部执行铸币逻辑

⚠️ mint 函数铸造出来的 LP，先铸给 Pair 合约自身，不会直接发给用户

Step 6：Pair 将新铸造的 LP Token transfer 还给用户

mint 完成后，Pair 把刚生成的 LP Token 转账到用户钱包。 至此用户拿到 LP 凭证，整个 addLiquidity 流程结束。

移除流动性

L0−L1L0=ST\boldsymbol{\frac{L_0-L1}{L0}=\frac{S}{T}}

移除流动性的时候，L0>L1L_0>L_1 因为：

L0=x0⋅y0L_0=\sqrt{x_0\cdot y_0}

L1=(x0−dx)(y0−dy)L_1=\sqrt{(x_0-dx)(y_0-dy)}

x0y0=x0−dxy0−dy\frac{x_0}{y_0}=\frac{x_0-dx}{y_0-dy}

代入到上面的公式中 L0−L1L0=ST\boldsymbol{\frac{L_0-L1}{L0}=\frac{S}{T}}

x0⋅y0−(x0−dx)(y0−dy)x0⋅y0=ST\boldsymbol{\frac{\sqrt{x_0\cdot y_0}-\sqrt{(x_0-dx)(y_0-dy)}}{\sqrt{x_0\cdot y_0}}=\frac{S}{T}}

因为：dxx0=dyy0=r\dfrac{dx}{x_0}=\dfrac{dy}{y_0}=r，r 是缩小倍数。

设：dx=r⋅x0dx = r\cdot x_0 dy=r⋅y0dy = r\cdot y_0

x0⋅y0−(x0−r⋅x0)(y0−r⋅y0)x0⋅y0=ST\boldsymbol{\frac{\sqrt{x_0\cdot y_0}-\sqrt{(x_0-r\cdot x_0)(y_0-r\cdot y_0)}}{\sqrt{x_0\cdot y_0}}=\frac{S}{T}}

x0⋅y0−(x0(1−r)⋅y0(1−r)x0⋅y0=ST\boldsymbol{\frac{\sqrt{x_0\cdot y_0}-\sqrt{(x_0(1-r)\cdot y_0(1-r)}}{\sqrt{x_0\cdot y_0}}=\frac{S}{T}}

x0⋅y0−x0⋅y0⋅(1−r)2x0⋅y0=ST\boldsymbol{\frac{\sqrt{x_0\cdot y_0}-\sqrt{x_0\cdot y_0} \cdot \sqrt{(1-r)^2}}{\sqrt{x_0\cdot y_0}}=\frac{S}{T}}

x0⋅y0−x0⋅y0⋅(1−r)x0⋅y0=ST\boldsymbol{\frac{\sqrt{x_0\cdot y_0}-\sqrt{x_0\cdot y_0} \cdot (1-r)}{\sqrt{x_0\cdot y_0}}=\frac{S}{T}}

x0⋅y0⋅rx0⋅y0=ST\boldsymbol{\frac{\sqrt{x_0\cdot y_0}\cdot r}{\sqrt{x_0\cdot y_0}}=\frac{S}{T}} r=STr=\frac{S}{T}

因为：r=dxx0=dyy0r=\dfrac{dx}{x_0}=\dfrac{dy}{y_0} 所以： dxx0=dyy0=ST\boldsymbol{\color{red}{\dfrac{dx}{x_0}=\dfrac{dy}{y_0}=\frac{S}{T}}}

即：

reserve0: dx=ST⋅x0\boldsymbol{\color{red}{dx=\frac{S}{T}\cdot x_0}}

reserve1: dy=ST⋅y0\boldsymbol{\color{red}{dy=\frac{S}{T}\cdot y_0}}

    // **** REMOVE LIQUIDITY ****
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) public virtual override ensure(deadline) returns (uint amountA, uint amountB) {
        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
        IUniswapV2Pair(pair).transferFrom(msg.sender, pair, liquidity); // send liquidity to pair
        (uint amount0, uint amount1) = IUniswapV2Pair(pair).burn(to);
        (address token0,) = UniswapV2Library.sortTokens(tokenA, tokenB);
        (amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
        require(amountA >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
        require(amountB >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT');
    }

Uniswap V2 里移除流动性的实现

flowchart LR
    User[&#34;👤 用户&#34;]
    Router[&#34;UniswapV2 Router&#34;]
    Pair[&#34;DAI/WETH Pair 池子&#34;]

    %% 1. 用户发起移除流动性
    User -- &#34;1. removeLiquidity&#34; --> Router
    %% 2. transferFrom：把用户的LP Token转入Pair合约
    User -- &#34;2. transferFrom LP Token&#34; --> Pair
    %% 3. Router调用Pair.burn()销毁LP
    Router -- &#34;3. burn()&#34; --> Pair
    %% 4. Pair转出对应的两种代币返还用户
    Pair -- &#34;4. transfer DAI / WETH&#34; --> User

Step 1: 用户调用 Router.removeLiquidity 用户发起交易，指定要销毁多少 LP Token，设置最小收到 DAI、WETH 滑点保护。

Step 2: transferFrom LP Token 用户必须提前授权 Router 操作自己的 LP；Router 执行 transferFrom，将用户钱包里的 LP Token 转移到 Pair 合约地址。

⚠️ burn 函数要求 LP 先转入 Pair，不能直接销毁用户账户上的 LP。

Step 3: Router 调用 Pair.burn () 核心逻辑就在 burn：

  • 读取当前池子储备 (x_0,y_0)、当前 LP 总供给 T
  • 根据转入的 LP 数量 S，计算份额 (r=\dfrac{S}{T})
  • 算出用户可取走代币：(dx=r\cdot x_0,\ dy=r\cdot y_0)
  • 销毁转入的 LP Token（减少 Pair 的 totalSupply）

Step 4: Pair 把 DAI、WETH transfer 还给用户 池子扣除对应储备，将等值两种代币转账回用户地址，流程结束。

和 addLiquidity 做对称对比

  • addLiquidity：代币进池子 → mint 铸造 LP 发给用户
  • removeLiquidity：LP 进池子 → burn 销毁 LP，代币还给用户
avatar
文章
阅读
粉丝