利用闪电贷对Aave资金池做清算

这篇帖子基本代码来自这里，它实际上是一道填空题，用来考察对solidity和一些区块链基本概念的熟悉程度。

基本原理

Aave 采用超额抵押机制，借款人需要提供一定比例的抵押品（如 ETH、WBTC），然后借出一定金额的资产（如 USDC、DAI）。如果借款人的健康系数降至 1 以下，意味着抵押品价值不足以覆盖贷款，这时可以被清算。清算人可以以低于市场价的折扣（一般 5%-10%）获得抵押品。

比如，借款人有 10 ETH 作为抵押，借了 20,000 USDC，由于 ETH 价格下跌，HF 变为 0.95，可以清算。此时你偿还 5,000 USDC 的债务，并以 5% 折扣获取等值 ETH。

你可能会问，假设我代借款人偿还了所有贷款，以5%的折扣获得等量的抵押品ETH，但是如果这样的话我应该能获得比全部抵押品更多的ETH，这部分ETH由谁给？

事实上这个问题并不存在，清算其实都是部分的，你只能帮他还50%左右的债。此时如果借款人选择偿还剩余 50% 的债务，那他能取回的抵押品会减少，因为部分抵押品已经被清算人以折扣价拿走了。如果他一直不还钱，就会触发进一步清算，直到健康指数回到1。

从头实现

大概步骤

1. 检查目标用户（liquidationTarget）的健康因子是否低于 1，决定是否可以进行清算；
2. 通过 Uniswap V2 从 WETH/USDT 池子中借出 USDT（利用闪电贷）；
3. 使用借来的 USDT 在 Aave 进行清算（liquidationCall），获取用户抵押的 WBTC；
4. 在 Uniswap V2 WBTC/WETH 池子中卖出 WBTC，换回 WETH；
5. 使用获得的 WETH 归还闪电贷（WETH/USDT 池）；
6. 多余的 WETH 转回给调用者，从而实现套利。

定义接口

接口中要写上所有期望合约实现的功能。

interface ILendingPool

getUserAccountData 获取用户资产情况，包括抵押资产、债务、健康因子，揪出能被清算的人：

function getUserAccountData(address user)
        external
        view
        returns (
            uint256 totalCollateralETH,
            uint256 totalDebtETH,
            uint256 availableBorrowsETH,
            uint256 currentLiquidationThreshold,
            uint256 ltv,
            uint256 healthFactor
        );

liquidationCall 进行清算，将 debtAsset（债务资产，例如 USDT）支付给 Aave，获得 collateralAsset（抵押资产，例如 WBTC）：

function liquidationCall(
    address collateralAsset,
    address debtAsset,
    address user,
    uint256 debtToCover,
    bool receiveAToken
) external;

interface IERC20

标准ERC20代币接口：

interface IERC20 {
    function balanceOf(address owner) external view returns (uint256);
    function approve(address spender, uint256 value) external;
    function transfer(address to, uint256 value) external returns (bool);
}

IWETH

这个接口相比ERC20具备 withdraw(uint256) 方法，可将 WETH 兑换成 ETH：

interface IWETH is IERC20 {
    function withdraw(uint256) external;
}

interface IUniswapV2Pair

用于闪电贷，amount0Out 或 amount1Out 之一必须为 0，表示借出的代币数量：

function swap(
    uint256 amount0Out,
    uint256 amount1Out,
    address to,
    bytes calldata data
) external;

合约

变量

WBTC、WETH、USDT 的合约地址：

IERC20 constant WBTC = IERC20(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599);
IWETH constant WETH = IWETH(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
IERC20 constant USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);

获取 Uniswap 交易对地址，连接到两个流动性池便于后续快速出手资产：

IUniswapV2Factory constant uniswapV2Factory = IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUniswapV2Pair immutable uniswapV2Pair_WETH_USDT; // Pool1
IUniswapV2Pair immutable uniswapV2Pair_WBTC_WETH; // Pool2

其他用到的变量：

ILendingPool constant lendingPool = ILendingPool(0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9);
address constant liquidationTarget = 0x59CE4a2AC5bC3f5F225439B2993b86B42f6d3e9F;
uint debt_USDT;

分别是Aave的资金池、清算目标地址、目标的欠款值。

计算交易金额

输入 amountIn ，得到能兑换出的 amountOut，手续费0.3%：

function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) internal pure returns (uint256 amountOut) {
        require(amountIn > 0, "UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT");
        require(
            reserveIn > 0 && reserveOut > 0,
            "UniswapV2Library: INSUFFICIENT_LIQUIDITY"
        );
        uint256 amountInWithFee = amountIn * 997;
        uint256 numerator = amountInWithFee * reserveOut;
        uint256 denominator = reserveIn * 1000 + amountInWithFee;
        amountOut = numerator / denominator;
    }

构造器

constructor() {
    uniswapV2Pair_WETH_USDT = IUniswapV2Pair(uniswapV2Factory.getPair(address(WETH), address(USDT)));
    uniswapV2Pair_WBTC_WETH = IUniswapV2Pair(uniswapV2Factory.getPair(address(WBTC), address(WETH)));
    debt_USDT = 10000000000;
}

获取两个交易对地址，并且固定帮他还10000USDT。

清算逻辑

function operate() external {
        uint256 totalCollateralETH;
        uint256 totalDebtETH;
        uint256 availableBorrowsETH;
        uint256 currentLiquidationThreshold;
        uint256 ltv;
        uint256 healthFactor;
        (
            totalCollateralETH,
            totalDebtETH,
            availableBorrowsETH,
            currentLiquidationThreshold,
            ltv,
            healthFactor
        ) = lendingPool.getUserAccountData(liquidationTarget);

        require(healthFactor < (10 ** health_factor_decimals), "Cannot liquidate; health factor must be below 1" );

		// 借款，从池子里借10000USDT到合约地址，清算目标
        uniswapV2Pair_WETH_USDT.swap(0, debt_USDT, address(this), "$");
		
		// 提款
        uint balance = WETH.balanceOf(address(this));
        WETH.withdraw(balance);
        
        // 把多余的WETH转给调用者
        payable(msg.sender).transfer(address(this).balance);
    }

交易回调

该函数会在 Uniswap V2 进行闪电贷（flash swap）时被调用，允许合约执行进一步操作。

function uniswapV2Call(
        address,
        uint256,
        uint256 amount1, // 交换的token1
        bytes calldata
    ) external override {
        assert(msg.sender == address(uniswapV2Pair_WETH_USDT));
        
        // 获取两个资金池储备
        (uint256 reserve_WETH_Pool1, uint256 reserve_USDT_Pool1, ) = uniswapV2Pair_WETH_USDT.getReserves(); // Pool1
        (uint256 reserve_WBTC_Pool2, uint256 reserve_WETH_Pool2, ) = uniswapV2Pair_WBTC_WETH.getReserves(); // Pool2
        
        // 清算目标账户
        uint debtToCover = amount1; // 代偿金额
        
        // 授权ledingpool使用合约中的USDT
        USDT.approve(address(lendingPool), debtToCover);
        
        // 清算 liquidationTarget 的 WBTC 抵押资产
        // 最后的false参数表示要接收真实的 WBTC 作为清算奖励，而不是 aToken
        lendingPool.liquidationCall(address(WBTC), address(USDT), liquidationTarget, debtToCover, false);
        
        // 处理抵押品WBTC
        // 清点获利并转到pool2兑换成WETH
        uint collateral_WBTC = WBTC.balanceOf(address(this));        
        WBTC.transfer(address(uniswapV2Pair_WBTC_WETH), collateral_WBTC);
        
        // 兑换并转到调用者钱包
        uint amountOut_WETH = getAmountOut(collateral_WBTC, reserve_WBTC_Pool2, reserve_WETH_Pool2);
        uniswapV2Pair_WBTC_WETH.swap(0, amountOut_WETH, address(this), "");

		// 计算应还闪电贷并还款
        uint repay_WETH = getAmountIn(debtToCover, reserve_WETH_Pool1, reserve_USDT_Pool1);
        WETH.transfer(address(uniswapV2Pair_WETH_USDT), repay_WETH);
    }

合约的执行顺序

上面展示的代码并不全，只有一些关键的接口和逻辑。可以看出虽然operate()是执行清算的函数，但是真正的清算调用liquidationCall却在交易回调中实现。

执行清算时首先调用operate()，在里边借完闪电贷会触发回调，因为：

uniswapV2Pair_WETH_USDT.swap(0, debt_USDT, address(this), "$");

最后一个参数是data，它有值不为空。在 Uniswap V2 中，如果提供了 data 参数（非空），Uniswap 会在资金转移后立即调用 uniswapV2Call() 回调。

这里有一个容易犯的错误，就是不能图方便直接在operate()中清算。借款那行代码只是一个请求，它执行完后钱其实不一定到账，如果这个时候立即清算，可能会触发缺钱判定。而使用回调就没有这个问题，回调是钱到账之后触发的。

所以关于执行顺序，可以理解为operate发送借款请求后，代码进入回调函数，回调执行完再回到operate接着执行。

测试脚本

这是一个抽象合约，不能直接部署。构造器中并没有提供RPC，这是需要部署时提供的。其实这也是我第一次在非remix测试环境下部署合约，之前搞的都是单独的虚拟链。通过这道题也可以感受一下Ethers.js和solidity合约的配合过程。

在原始项目中，它提供了一个Hardhat测试脚本进行测试链复现用来部署合约，它最终会检查日志来确认清算成功，并计算清算者的盈利。

复现主网状态

await network.provider.request({
    method: "hardhat_reset",
    params: [{
      forking: {
        jsonRpcUrl: process.env.ALCHE_API,
        blockNumber: 12489619,
      }
    }]
});

它fork以太坊主网到本地来模拟真实链，并初始化了区块高度。其中的RPC接口需要在部署时提供（这里它是最后docker命令的一个参数）。

gas价格模拟

这里它把操作的gas费设为了0：

const gasPrice = 0;

初始化清算人

const accounts = await ethers.getSigners();
const liquidator = accounts[0].address;

const beforeLiquidationBalance = BigNumber.from(await hre.network.provider.request({
    method: "eth_getBalance",
    params: [liquidator],
}));

Hardhat默认提供20个测试账户，取第一个作为模拟清算人。读取 liquidator（清算人）的 ETH 余额，存入 beforeLiquidationBalance，后续用于计算利润。

部署合约

const LiquidationOperator = await ethers.getContractFactory("LiquidationOperator");
const liquidationOperator = await LiquidationOperator.deploy(overrides = {gasPrice: gasPrice});
await liquidationOperator.deployed();

这里和这篇文章讲过的一样，利用合约工厂部署刚才写的合约。

执行清算

const liquidationTx = await liquidationOperator.operate(overrides = {gasPrice: gasPrice});
const liquidationReceipt = await liquidationTx.wait();

合约部署后就可以从外部调它的接口，这里直接调operate。

这个js文件后续还有一些处理，这里略过，总之清算完成后收益会被自动计算并保存在profit.txt中。