Uniswap V2 详解：含代码示例的完整指南

blockmagnates
发布于 8小时前
阅读 51

本文详细介绍了Uniswap V2的核心机制，包括其核心/外围架构、流动性添加和移除、代币交换以及LP代币经济学。文章提供了实用的代码示例，展示了如何在Solidity中与Uniswap V2交互，并强调了安全最佳实践，如滑点保护、截止时间和安全批准，以构建可靠的去中心化交易应用。

![](https://img.learnblockchain.cn/2025/06/30/0PJIr7M4cbxyajg7g.png)

## 解码 Uniswap V2：带有代码示例的完整指南

Uniswap V2 通过引入自动做市商（AMM）彻底改变了去中心化交易，实现了无需许可的代币交换和流动性提供。在本综合指南中，我们将通过你可以立即实施的实用代码示例来解码 Uniswap V2 的核心机制。

## 理解 Uniswap V2 架构

Uniswap V2 实现了**核心/外围架构**，将基本功能与用户友好的界面分开。核心合约处理基本的交易逻辑并保护流动性池，而外围合约（如 Router）提供安全检查和易用性功能。

## 核心 vs 外围设计

精简的核心合约仅包含保护流动性所必需的逻辑，而外围合约处理交易者安全和用户体验。这种模块化方法允许外部助手在不迁移流动性的情况下进行改进和替换。

```
// Core: Minimal, secure, immutable
// 核心：最小化、安全、不可变
contract UniswapV2Pair {
    // Essential trading logic only
    // 仅包含必要的交易逻辑
}
```

```
// Periphery: User-friendly, upgradeable
// 外围：用户友好，可升级
contract UniswapV2Router02 {
    // Safety checks and convenience functions
    // 安全检查和便捷功能
}
```

## 设置你的合约

要与 Uniswap V2 交互，你需要创建路由合约的一个实例：

```
pragma solidity ^0.8.0;
```

```
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";contract UniswapV2Integration {
    address private constant ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    IUniswapV2Router02 public uniswapV2Router;

constructor() {
        uniswapV2Router = IUniswapV2Router02(ROUTER);
    }
}
```

**主要组件：**

- **Router Address**：UniswapV2Router02 的官方以太坊主网地址
- **Interface Declaration**：定义所有可用的路由函数
- **Instance Creation**：允许在你的合约中调用路由函数

## 增加流动性：成为流动性提供者

`addLiquidity()` 函数允许你为交易对提供流动性，并从每笔交易中赚取费用。

## 函数签名

```
function addLiquidity(
    address tokenA,
    address tokenB,
    uint amountADesired,
    uint amountBDesired,
    uint amountAMin,
    uint amountBMin,
    address to,
    uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
```

## 参数分解

- `tokenA/tokenB`：要配对的代币的合约地址
- `amountADesired/amountBDesired`：你期望的存款金额
- `amountAMin/amountBMin`：最小金额（滑点保护）
- `to`：接收 LP 代币的地址
- `deadline`：交易过期时间戳

## 实际实现

```
function addLiquidityToPool(
    address tokenA,
    address tokenB,
    uint256 amountA,
    uint256 amountB
) external {
    // Approve router to spend tokens
    // 授权路由器消费代币
    IERC20(tokenA).approve(address(uniswapV2Router), amountA);
    IERC20(tokenB).approve(address(uniswapV2Router), amountB);

// Add liquidity with 5% slippage tolerance
    // 增加流动性，滑点容忍度为 5%
    uniswapV2Router.addLiquidity(
        tokenA,
        tokenB,
        amountA,
        amountB,
        amountA * 95 / 100,  // 5% slippage protection
        amountB * 95 / 100,  // 5% slippage protection
        msg.sender,          // LP tokens to caller
        // LP 代币给调用者
        block.timestamp + 300 // 5 minute deadline
                              // 5 分钟截止时间
    );
}
```

## 内部机制：`addLiquidity()` 如何工作

理解内部的 `_addLiquidity()` 函数揭示了流动性供应背后的复杂逻辑：

## 交易对创建检查

```
if (IUniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)) {
    IUniswapV2Factory(factory).createPair(tokenA, tokenB);
}
```

## 基于储备金的计算

对于现有的交易对，该函数维护价格比率：

```
amountBOptimal = amountADesired.mul(reserveB) / reserveA;
```

```
if (amountBOptimal <= amountBDesired) {
    (amountA, amountB) = (amountADesired, amountBOptimal);
} else {
    amountAOptimal = amountBDesired.mul(reserveA) / reserveB;
    (amountA, amountB) = (amountAOptimal, amountBDesired);
}
```

## CREATE2 地址计算

Uniswap V2 使用确定性地址来提高 gas 效率：

```
pair = address(uint(keccak256(abi.encodePacked(
    hex'ff',
    factory,
    keccak256(abi.encodePacked(token0, token1)),
    hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
```

## 移除流动性：退出你的仓位

`removeLiquidity()` 函数允许你通过销毁 LP 代币来提取你的代币：

```
function removeLiquidity(
    address tokenA,
    address tokenB,
    uint liquidity,
    uint amountAMin,
    uint amountBMin,
    address to,
    uint deadline
) external returns (uint amountA, uint amountB);
```

## 实现示例

```
function removeLiquidityFromPool(
    address tokenA,
    address tokenB,
    uint256 liquidityAmount
) external {
    address pair = IUniswapV2Factory(factory).getPair(tokenA, tokenB);

// Approve router to spend LP tokens
    // 授权路由器消费 LP 代币
    IERC20(pair).approve(address(uniswapV2Router), liquidityAmount);

// Remove liquidity
    // 移除流动性
    uniswapV2Router.removeLiquidity(
        tokenA,
        tokenB,
        liquidityAmount,
        0, // Accept any amount of tokenA
           // 接受任何数量的 tokenA
        0, // Accept any amount of tokenB
           // 接受任何数量的 tokenB
        msg.sender,
        block.timestamp + 300
    );
}
```

## 代币互换：DeFi 交易的核心

`swapExactTokensForTokens()` 函数能够实现精确的代币兑换：

```
function swapExactTokensForTokens(
    uint amountIn,
    uint amountOutMin,
    address[] calldata path,
    address to,
    uint deadline
) external returns (uint[] memory amounts);
```

## 高级 Swap 实现

```
function swapTokens(
    address tokenIn,
    address tokenOut,
    uint256 amountIn,
    uint256 slippagePercent
) external {
    // Approve router
    // 授权路由器
    IERC20(tokenIn).approve(address(uniswapV2Router), amountIn);

// Calculate minimum output with slippage
    // 通过滑点计算最小输出
    address[] memory path = new address[](2);
    path[0] = tokenIn;
    path[1] = tokenOut;

uint[] memory amountsOut = uniswapV2Router.getAmountsOut(amountIn, path);
    uint amountOutMin = amountsOut[1] * (100 - slippagePercent) / 100;

// Execute swap
    // 执行兑换
    uniswapV2Router.swapExactTokensForTokens(
        amountIn,
        amountOutMin,
        path,
        msg.sender,
        block.timestamp + 300
    );
}
```

## 多跳兑换

对于没有直接交易对的代币，Uniswap 通过中间代币进行路由：

```
function multiHopSwap(uint256 amountIn) external {
    address[] memory path = new address[](3);
    path[0] = USDC_ADDRESS;  // Start with USDC
                               // 从 USDC 开始
    path[1] = WETH_ADDRESS;  // Route through WETH
                               // 通过 WETH 路由
    path[2] = DAI_ADDRESS;   // End with DAI
                               // 以 DAI 结束

IERC20(USDC_ADDRESS).approve(address(uniswapV2Router), amountIn);

uniswapV2Router.swapExactTokensForTokens(
        amountIn,
        0, // Calculate proper minimum in production
           // 在生产中计算适当的最小值
        path,
        msg.sender,
        block.timestamp + 300
    );
}
```

## LP 代币经济学：理解你的回报

当你提供流动性时，你会收到 ERC-20 LP 代币，代表你所占的池子份额：

## LP 代币特征

- 整个池子的**按比例所有权**
- 来自每笔交易的**费用累积**（V2 中为 0.3%）
- **可赎回**为基础代币加上赚取的费用

## 盈利能力因素

```
// Your share calculation
// 你的份额计算
uint256 yourPoolShare = (yourLPTokens * 100) / totalLPSupply;
uint256 yourTokenAShare = (poolReserveA * yourPoolShare) / 100;
uint256 yourTokenBShare = (poolReserveB * yourPoolShare) / 100;
```

## 安全注意事项和最佳实践

## 始终使用滑点保护

```
// Bad: No slippage protection
// 坏：没有滑点保护
uniswapV2Router.swapExactTokensForTokens(amountIn, 0, path, to, deadline);
```

```
// Good: Proper slippage protection
// 好：适当的滑点保护
uint256 amountOutMin = expectedAmount * 95 / 100; // 5% slippage
// 5% 滑点
uniswapV2Router.swapExactTokensForTokens(amountIn, amountOutMin, path, to, deadline);
```

## 实施适当的截止时间

```
// Bad: No deadline
// 坏：没有截止时间
uint deadline = type(uint).max;
```

```
// Good: Reasonable deadline
// 好：合理的截止时间
uint deadline = block.timestamp + 300; // 5 minutes
// 5 分钟
```

## 安全地处理授权

```
function safeApprove(address token, address spender, uint256 amount) internal {
    IERC20(token).approve(spender, 0); // Reset to 0 first
    // 首先重置为 0
    IERC20(token).approve(spender, amount);
}
```

## 完整的集成示例

这是一个全面的合约，演示了所有主要的 Uniswap V2 交互：

```
textpragma solidity ^0.8.0;
```

```
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";contract UniswapV2Manager {
    IUniswapV2Router02 public immutable uniswapV2Router;
    IUniswapV2Factory public immutable uniswapV2Factory;

constructor() {
        uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        uniswapV2Factory = IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
    }

function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountA,
        uint256 amountB,
        uint256 slippage
    ) external returns (uint256, uint256, uint256) {
        IERC20(tokenA).transferFrom(msg.sender, address(this), amountA);
        IERC20(tokenB).transferFrom(msg.sender, address(this), amountB);

IERC20(tokenA).approve(address(uniswapV2Router), amountA);
        IERC20(tokenB).approve(address(uniswapV2Router), amountB);

uint256 amountAMin = amountA * (100 - slippage) / 100;
        uint256 amountBMin = amountB * (100 - slippage) / 100;

return uniswapV2Router.addLiquidity(
            tokenA,
            tokenB,
            amountA,
            amountB,
            amountAMin,
            amountBMin,
            msg.sender,
            block.timestamp + 300
        );
    }

function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 slippage
    ) external returns (uint256, uint256) {
        address pair = uniswapV2Factory.getPair(tokenA, tokenB);
        IERC20(pair).transferFrom(msg.sender, address(this), liquidity);
        IERC20(pair).approve(address(uniswapV2Router), liquidity);

// Get current reserves to calculate minimums
        // 获取当前储备金以计算最小值
        (uint256 reserveA, uint256 reserveB,) = IUniswapV2Pair(pair).getReserves();
        uint256 totalSupply = IERC20(pair).totalSupply();

uint256 amountAMin = (reserveA * liquidity / totalSupply) * (100 - slippage) / 100;
        uint256 amountBMin = (reserveB * liquidity / totalSupply) * (100 - slippage) / 100;

return uniswapV2Router.removeLiquidity(
            tokenA,
            tokenB,
            liquidity,
            amountAMin,
            amountBMin,
            msg.sender,
            block.timestamp + 300
        );
    }

function swapExactTokensForTokens(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 slippage
    ) external returns (uint256[] memory) {
        IERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn);
        IERC20(tokenIn).approve(address(uniswapV2Router), amountIn);

address[] memory path = new address[](2);
        path[0] = tokenIn;
        path[1] = tokenOut;

uint256[] memory amountsOut = uniswapV2Router.getAmountsOut(amountIn, path);
        uint256 amountOutMin = amountsOut[1] * (100 - slippage) / 100;

return uniswapV2Router.swapExactTokensForTokens(
            amountIn,
            amountOutMin,
            path,
            msg.sender,
            block.timestamp + 300
        );
    }
}
```

## 结论

Uniswap V2 的优雅设计将简单性与强大的功能相结合。通过理解流动性提供、代币交换和底层数学模型的核心机制，开发者可以构建复杂的 DeFi 应用，利用自动做市商。

成功集成 Uniswap V2 的关键在于：

- **适当的滑点保护**，以防止不利的交易
- **安全的代币授权**，以维护用户资金安全
- **高效的路由**，以实现最佳的交换执行
- **理解 LP 经济学**，以实现可持续的流动性供应

无论你构建的是 DEX 聚合器、收益耕作协议还是简单的代币交换界面，Uniswap V2 经过实战检验的基础设施都为可靠的去中心化交易提供了基础。

请记住，在部署到主网之前，始终在测试网上彻底测试你的实现，并考虑 gas 成本和你的设计选择对用户体验的影响。

>- 原文链接： [blog.blockmagnates.com/u...](https://blog.blockmagnates.com/uniswap-v2-decoded-a-complete-guide-with-code-examples-f6c70986c756)
>- 登链社区 AI 助手，为大家转译优秀英文文章，如有翻译不通的地方，还请包涵～

解码 Uniswap V2：带有代码示例的完整指南

理解 Uniswap V2 架构

Uniswap V2 实现了核心/外围架构，将基本功能与用户友好的界面分开。核心合约处理基本的交易逻辑并保护流动性池，而外围合约（如 Router）提供安全检查和易用性功能。

核心 vs 外围设计

// Core: Minimal, secure, immutable
// 核心：最小化、安全、不可变
contract UniswapV2Pair {
    // Essential trading logic only
    // 仅包含必要的交易逻辑
}

// Periphery: User-friendly, upgradeable
// 外围：用户友好，可升级
contract UniswapV2Router02 {
    // Safety checks and convenience functions
    // 安全检查和便捷功能
}

设置你的合约

要与 Uniswap V2 交互，你需要创建路由合约的一个实例：

pragma solidity ^0.8.0;

import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";contract UniswapV2Integration {
    address private constant ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    IUniswapV2Router02 public uniswapV2Router;

    constructor() {
        uniswapV2Router = IUniswapV2Router02(ROUTER);
    }
}

主要组件：

Router Address：UniswapV2Router02 的官方以太坊主网地址
Interface Declaration：定义所有可用的路由函数
Instance Creation：允许在你的合约中调用路由函数

增加流动性：成为流动性提供者

addLiquidity() 函数允许你为交易对提供流动性，并从每笔交易中赚取费用。

函数签名

function addLiquidity(
    address tokenA,
    address tokenB,
    uint amountADesired,
    uint amountBDesired,
    uint amountAMin,
    uint amountBMin,
    address to,
    uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);

参数分解

tokenA/tokenB：要配对的代币的合约地址
amountADesired/amountBDesired：你期望的存款金额
amountAMin/amountBMin：最小金额（滑点保护）
to：接收 LP 代币的地址
deadline：交易过期时间戳

实际实现

function addLiquidityToPool(
    address tokenA,
    address tokenB,
    uint256 amountA,
    uint256 amountB
) external {
    // Approve router to spend tokens
    // 授权路由器消费代币
    IERC20(tokenA).approve(address(uniswapV2Router), amountA);
    IERC20(tokenB).approve(address(uniswapV2Router), amountB);

    // Add liquidity with 5% slippage tolerance
    // 增加流动性，滑点容忍度为 5%
    uniswapV2Router.addLiquidity(
        tokenA,
        tokenB,
        amountA,
        amountB,
        amountA * 95 / 100,  // 5% slippage protection
        amountB * 95 / 100,  // 5% slippage protection
        msg.sender,          // LP tokens to caller
        // LP 代币给调用者
        block.timestamp + 300 // 5 minute deadline
                              // 5 分钟截止时间
    );
}

内部机制：`addLiquidity()` 如何工作

理解内部的 _addLiquidity() 函数揭示了流动性供应背后的复杂逻辑：

交易对创建检查

if (IUniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)) {
    IUniswapV2Factory(factory).createPair(tokenA, tokenB);
}

基于储备金的计算

对于现有的交易对，该函数维护价格比率：

amountBOptimal = amountADesired.mul(reserveB) / reserveA;

if (amountBOptimal &lt;= amountBDesired) {
    (amountA, amountB) = (amountADesired, amountBOptimal);
} else {
    amountAOptimal = amountBDesired.mul(reserveA) / reserveB;
    (amountA, amountB) = (amountAOptimal, amountBDesired);
}

CREATE2 地址计算

Uniswap V2 使用确定性地址来提高 gas 效率：

pair = address(uint(keccak256(abi.encodePacked(
    hex'ff',
    factory,
    keccak256(abi.encodePacked(token0, token1)),
    hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));

移除流动性：退出你的仓位

removeLiquidity() 函数允许你通过销毁 LP 代币来提取你的代币：

function removeLiquidity(
    address tokenA,
    address tokenB,
    uint liquidity,
    uint amountAMin,
    uint amountBMin,
    address to,
    uint deadline
) external returns (uint amountA, uint amountB);

实现示例

function removeLiquidityFromPool(
    address tokenA,
    address tokenB,
    uint256 liquidityAmount
) external {
    address pair = IUniswapV2Factory(factory).getPair(tokenA, tokenB);

    // Approve router to spend LP tokens
    // 授权路由器消费 LP 代币
    IERC20(pair).approve(address(uniswapV2Router), liquidityAmount);

    // Remove liquidity
    // 移除流动性
    uniswapV2Router.removeLiquidity(
        tokenA,
        tokenB,
        liquidityAmount,
        0, // Accept any amount of tokenA
           // 接受任何数量的 tokenA
        0, // Accept any amount of tokenB
           // 接受任何数量的 tokenB
        msg.sender,
        block.timestamp + 300
    );
}

代币互换：DeFi 交易的核心

swapExactTokensForTokens() 函数能够实现精确的代币兑换：

function swapExactTokensForTokens(
    uint amountIn,
    uint amountOutMin,
    address[] calldata path,
    address to,
    uint deadline
) external returns (uint[] memory amounts);

高级 Swap 实现

function swapTokens(
    address tokenIn,
    address tokenOut,
    uint256 amountIn,
    uint256 slippagePercent
) external {
    // Approve router
    // 授权路由器
    IERC20(tokenIn).approve(address(uniswapV2Router), amountIn);

    // Calculate minimum output with slippage
    // 通过滑点计算最小输出
    address[] memory path = new address[](2);
    path[0] = tokenIn;
    path[1] = tokenOut;

    uint[] memory amountsOut = uniswapV2Router.getAmountsOut(amountIn, path);
    uint amountOutMin = amountsOut[1] * (100 - slippagePercent) / 100;

    // Execute swap
    // 执行兑换
    uniswapV2Router.swapExactTokensForTokens(
        amountIn,
        amountOutMin,
        path,
        msg.sender,
        block.timestamp + 300
    );
}

多跳兑换

对于没有直接交易对的代币，Uniswap 通过中间代币进行路由：

function multiHopSwap(uint256 amountIn) external {
    address[] memory path = new address[](3);
    path[0] = USDC_ADDRESS;  // Start with USDC
                               // 从 USDC 开始
    path[1] = WETH_ADDRESS;  // Route through WETH
                               // 通过 WETH 路由
    path[2] = DAI_ADDRESS;   // End with DAI
                               // 以 DAI 结束

    IERC20(USDC_ADDRESS).approve(address(uniswapV2Router), amountIn);

    uniswapV2Router.swapExactTokensForTokens(
        amountIn,
        0, // Calculate proper minimum in production
           // 在生产中计算适当的最小值
        path,
        msg.sender,
        block.timestamp + 300
    );
}

LP 代币经济学：理解你的回报

当你提供流动性时，你会收到 ERC-20 LP 代币，代表你所占的池子份额：

LP 代币特征

整个池子的按比例所有权
来自每笔交易的费用累积（V2 中为 0.3%）
可赎回为基础代币加上赚取的费用

盈利能力因素

// Your share calculation
// 你的份额计算
uint256 yourPoolShare = (yourLPTokens * 100) / totalLPSupply;
uint256 yourTokenAShare = (poolReserveA * yourPoolShare) / 100;
uint256 yourTokenBShare = (poolReserveB * yourPoolShare) / 100;

安全注意事项和最佳实践

始终使用滑点保护

// Bad: No slippage protection
// 坏：没有滑点保护
uniswapV2Router.swapExactTokensForTokens(amountIn, 0, path, to, deadline);

// Good: Proper slippage protection
// 好：适当的滑点保护
uint256 amountOutMin = expectedAmount * 95 / 100; // 5% slippage
// 5% 滑点
uniswapV2Router.swapExactTokensForTokens(amountIn, amountOutMin, path, to, deadline);

实施适当的截止时间

// Bad: No deadline
// 坏：没有截止时间
uint deadline = type(uint).max;

// Good: Reasonable deadline
// 好：合理的截止时间
uint deadline = block.timestamp + 300; // 5 minutes
// 5 分钟

安全地处理授权

function safeApprove(address token, address spender, uint256 amount) internal {
    IERC20(token).approve(spender, 0); // Reset to 0 first
    // 首先重置为 0
    IERC20(token).approve(spender, amount);
}

完整的集成示例

这是一个全面的合约，演示了所有主要的 Uniswap V2 交互：

textpragma solidity ^0.8.0;

import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";contract UniswapV2Manager {
    IUniswapV2Router02 public immutable uniswapV2Router;
    IUniswapV2Factory public immutable uniswapV2Factory;

    constructor() {
        uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        uniswapV2Factory = IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
    }

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountA,
        uint256 amountB,
        uint256 slippage
    ) external returns (uint256, uint256, uint256) {
        IERC20(tokenA).transferFrom(msg.sender, address(this), amountA);
        IERC20(tokenB).transferFrom(msg.sender, address(this), amountB);

        IERC20(tokenA).approve(address(uniswapV2Router), amountA);
        IERC20(tokenB).approve(address(uniswapV2Router), amountB);

        uint256 amountAMin = amountA * (100 - slippage) / 100;
        uint256 amountBMin = amountB * (100 - slippage) / 100;

        return uniswapV2Router.addLiquidity(
            tokenA,
            tokenB,
            amountA,
            amountB,
            amountAMin,
            amountBMin,
            msg.sender,
            block.timestamp + 300
        );
    }

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 slippage
    ) external returns (uint256, uint256) {
        address pair = uniswapV2Factory.getPair(tokenA, tokenB);
        IERC20(pair).transferFrom(msg.sender, address(this), liquidity);
        IERC20(pair).approve(address(uniswapV2Router), liquidity);

        // Get current reserves to calculate minimums
        // 获取当前储备金以计算最小值
        (uint256 reserveA, uint256 reserveB,) = IUniswapV2Pair(pair).getReserves();
        uint256 totalSupply = IERC20(pair).totalSupply();

        uint256 amountAMin = (reserveA * liquidity / totalSupply) * (100 - slippage) / 100;
        uint256 amountBMin = (reserveB * liquidity / totalSupply) * (100 - slippage) / 100;

        return uniswapV2Router.removeLiquidity(
            tokenA,
            tokenB,
            liquidity,
            amountAMin,
            amountBMin,
            msg.sender,
            block.timestamp + 300
        );
    }

    function swapExactTokensForTokens(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 slippage
    ) external returns (uint256[] memory) {
        IERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn);
        IERC20(tokenIn).approve(address(uniswapV2Router), amountIn);

        address[] memory path = new address[](2);
        path[0] = tokenIn;
        path[1] = tokenOut;

        uint256[] memory amountsOut = uniswapV2Router.getAmountsOut(amountIn, path);
        uint256 amountOutMin = amountsOut[1] * (100 - slippage) / 100;

        return uniswapV2Router.swapExactTokensForTokens(
            amountIn,
            amountOutMin,
            path,
            msg.sender,
            block.timestamp + 300
        );
    }
}

结论

成功集成 Uniswap V2 的关键在于：

适当的滑点保护，以防止不利的交易
安全的代币授权，以维护用户资金安全
高效的路由，以实现最佳的交换执行
理解 LP 经济学，以实现可持续的流动性供应

无论你构建的是 DEX 聚合器、收益耕作协议还是简单的代币交换界面，Uniswap V2 经过实战检验的基础设施都为可靠的去中心化交易提供了基础。

请记住，在部署到主网之前，始终在测试网上彻底测试你的实现，并考虑 gas 成本和你的设计选择对用户体验的影响。

原文链接： blog.blockmagnates.com/u...

登链社区 AI 助手，为大家转译优秀英文文章，如有翻译不通的地方，还请包涵～

翻译
学分: 0
分类: DeFi
标签: Uniswap V2 自动化做市商 AMM 流动性提供代币交换 Solidity 智能合约

本文参与登链社区写作激励计划，好文好收益，欢迎正在阅读的你也加入。

Uniswap V2 详解：含代码示例的完整指南

解码 Uniswap V2：带有代码示例的完整指南

理解 Uniswap V2 架构

核心 vs 外围设计

设置你的合约

增加流动性：成为流动性提供者

函数签名

参数分解

实际实现

内部机制：`addLiquidity()` 如何工作

交易对创建检查

基于储备金的计算

CREATE2 地址计算

移除流动性：退出你的仓位

实现示例

代币互换：DeFi 交易的核心

高级 Swap 实现

多跳兑换

LP 代币经济学：理解你的回报

LP 代币特征

盈利能力因素

安全注意事项和最佳实践

始终使用滑点保护

实施适当的截止时间

安全地处理授权

完整的集成示例

结论

0 条评论

文章目录

Uniswap V2 详解：含代码示例的完整指南

解码 Uniswap V2：带有代码示例的完整指南

理解 Uniswap V2 架构

核心 vs 外围设计

设置你的合约

增加流动性：成为流动性提供者

函数签名

参数分解

实际实现

内部机制：addLiquidity() 如何工作

交易对创建检查

基于储备金的计算

CREATE2 地址计算

移除流动性：退出你的仓位

实现示例

代币互换：DeFi 交易的核心

高级 Swap 实现

多跳兑换

LP 代币经济学：理解你的回报

LP 代币特征

盈利能力因素

安全注意事项和最佳实践

始终使用滑点保护

实施适当的截止时间

安全地处理授权

完整的集成示例

结论

0 条评论

文章目录

内部机制：`addLiquidity()` 如何工作