知道以太坊Merge之后要分叉出POW链是一个月前，大概8月中下旬，当时有两个团队准备分叉以太坊，一个是宝二爷的团队EthereumPow，另一个是Classzz团队的EthereumFair。当时预想到，分叉会把以太坊上的所有状态复制一遍，在发生分叉以后，由于除了分叉币ETHW/ETHF有潜在价值，其它币都没有价值，所以一定会有人或者机器人通过事先准备好的前端页面或者程序，将所有token都兑换为分叉币，这种兑换大概率发生在Uniswap/Sushiswap/Curve这些Dex上面，导致分叉币的价格出现巨大波动，这时不同的Dex之间会出现巨大价差。

套利机器人分为两部分，一个是部署在以太坊上的Solidity合约，这个没有任何变动，因为分叉后合约也会复制一份，另一个是本地的监控机器人，代码在原来的基础上重做了一个分支，做了轻微改动：

(1) 套利的目标token从原来的任意token变为只要WETH

(2)只监控Curve/Uniswap/Suhiswap/Balancer上包含WETH(数量在10个以上)的池子

(3)为了在与其它机器人的竞争中占得先机，把初始的gas_price设置为基础gas_price+50gwei, 在钱包里放0.5个ETH作为支付初始gas的本金

(4)在发送交易的字段里加入chainId，防止transaction被拿到以太坊主网上进行重放攻击

(5)准备两套程序部署在美东的服务器上面，把RPCendpoint作为配置参数，等待官方公布时再更改

2. 插曲

9月初的时候，EthereumPow团队宣布冻结所有包含WETH数额大的池子，导致套利机器人直接失效，但后来又宣布不冻结，虚惊一场。

3. EthereumFair上线

9月15日下午，以太坊成功Merge，EthereumFair团队在16:00左右率先上线了分叉网并公布了RPC endpoint，测试了一下连接正常，但是区块高度一直不更新，官方说是矿工节点还没同步，就一直等到19:00点左右开始正常出块，于是改好配置文件上线机器人。

上线过程比预想的顺利，看了交易日志，第一个区块就获利2000个ETF，后面一直运行比较丝滑，看了一下每一笔交易的排名，基本上都在区块的前两名，说明这个链的竞争不是很激烈。由于官方给的区块链浏览器打不开，所以没法看到套利合约总共赚了多少个WETH，所以在本地写了个小程序监控合约里的WETH数量, 大概3000个的时候，暂停了一下程序，调用合约的WETHtoETH()换成ETH，然后调用turnOutETH取到钱包里。然后重启程序，这样钱包里就有足够的币支付后来的gas了。

过程中间偶尔会出现一些交易revert失败的情况，当时比较费解，因为Solidity代码里已经有避免出现revert的机制。由于不影响大局，所以暂时没有管它，准备EthereumPow的上线。

4. EthereumPow上线

EthereumPow的官推一直拖延到10:00才公布RPC endpoint, 公布的一瞬间就改了配置文件，上线。这次上线就不顺利了，过程磕磕绊绊。

首先从日志里了解到有一些交易成功了，然后就一直发送交易失败，日志滚动地飞快，我的脑袋也开始飞快运转。首先，检查一下套利合约里赚了多少个WETH，以及钱包里的0.5个分叉币还剩下多少? 我打开区块链浏览器，无法访问, 然后用刚才那个程序读取一下，也读不出来，连接超时!也就是说我本地无法访问它的RPC endpoint，换上VPN也不行。还有个办法，通过日志去分析，但这样就太耽误时间了。现在完全是黑箱状态。最后只有登录到服务器上写个小程序，这下读出来了，赚了500个WETH，应该是头几笔交易赚的。

程序还在报错，一直发送交易失败，想了几分钟，大概想明白了: 因为我的程序每发送一笔交易，会用web3.getTransactionReceipt获取交易结果(成功/失败), 如果过去两个区块还获取不到结果，就直接跳过去监控下一次交易机会。因为开盘几分钟的基础gas_price很大，所以我的gas费(基础gas_price+50gwei)也很大，这时由于网络拥堵gas_price持续增加到我的gas费之上，我的这笔交易就变成pending状态了，后来基础gas_price降下来了但是这笔交易不知什么原因还是pending状态，然后第二笔交易报进去使用的是同样的nonce，gas费还比上一笔交易低，这是不允许的(要replace上一笔交易必须gas费要更高)，所以就一直报单不成功。找到问题之后立马暂停程序，把gas费修改为基础gas_price+200gwei，重启，后面的交易就成功了。

这时，监控套利合约里的WETH数量，以每个区块几个～几十个的速度增长，因为刚才一顿操作浪费了5~10分钟，已经错过了开盘几分钟的黄金时间。

这样持续了2个小时左右，程序突然掉线，无法连接RPC，不知道什么原因。打开区块链浏览器，还在正常出块，所以不是节点的原因，我推断因为我的机器人访问次数过多触发了PRC节点的保护机制，把我的IP给禁了。这个时候再租一个新的VPS服务器，部署上线又很花时间，所以这边只有放弃，转到EthereumFair那边去。

5. bug fixed

EthereumFair的程序依然时不时发出revert的交易。首先，为了防止revert,在套利合约里，在开始套利之前，会先去检查套利机会是否还存在。如果这笔交易上链时排在了其它套利机器人的后面，套利机会就不存在了，这个时候就直接返回不做任何操作，避免了交易被revert白白浪费gas。为什么交易还会revert呢?

通过日志发现，失败的交易都来自于和UniswapV3的池子进行交互，这时我 想到，在检查UniswapV3的套利机会时，会调用UniswapV3Quote合约计算套利结果，UniswapV3Quote合约里有个try catch的操作，可能跟这个有关。没来的及想具体原因，我先调用套利合约，把事先检查套利机会的开关关掉，这样就不会和UniswapV3Quote发生交互。由于这个链基本没有竞争对手，所以不用担心被其它机器人抢的问题。重新部署上线，果然没有失败的交易了。

6. 尾声

过了2个小时之后，EthereumPow的RPC节点又可以访问了，重新上线。每个区块能赚0.1~1.5个WETH，竞争还是十分激烈，交易经常排在几十名开外。EthereumFair的竞争虽然没那么激烈，但是每个区块的奖励也只有个位数，池子在被逐渐掏空。再过10个小时之后，基本上两个链都挖不到币了。

7. 总结

经过一夜的奋战，收获13000个ETF和1500个ETHW，冲到交易所直接卖掉，获利4w美刀。

EthereumFair的整个过程比较丝滑，访问没有出现任何问题，比预想的顺利，抛开币本身的价值，这个团队的技术还是比较过硬的。

EthereumPow比较可惜，由于自己代码上的bug导致错过了开盘的黄金时间，中途又掉线两个小时，最后只吃了一个鱼尾。

整个过程给自己打80分，写文章记录一下，虽然这里面的经验教训以后也用不到了，毕竟以太坊分叉一辈子就这一次了，但是以后给别人吹牛逼可以说自己是在以太坊分叉日撸过币的男人了。

GitHub - yueying007/blockchainclass

Contribute to yueying007/blockchainclass development by creating an account on GitHub.

https://github.com

流程

我们在智能合约中实现一个双边套利的操作：

1. 发起闪电贷WETH

2. 在Curve中把WETH兑换为USDT

3. 在Uniswap中把USDT兑换为WETH

4. 归还闪电贷WETH

结构体

在上一节中，我们已经分别实现了Curve和Uniswap的兑换操作，接下来，需要定义一个结构体，来保存一笔兑换的参数信息：

struct SwapData {
    uint function_id;        
    uint256 token_in_id;
    uint256 token_out_id;
    address token_in;
    address token_out;
    address pool;
}

同时，在还款信息RepayData中加入一个SwapData类型的数组SwapData[]，用来告诉合约这些兑换参数的信息。并加入一个标志direct_repay用来区分获得闪电贷后的操作(直接归还/进行套利):

struct RepayData {
    SwapData[] swap_data;
    address repay_token;
    uint256 repay_amount;
    address recipient;
    bool direct_repay;
}

入口函数

定义一个execute()函数作为套利的入口函数。

function execute(bytes[] memory data, uint256 amount_in) public onlyOwner Lock returns(uint256) {
    SwapData[] memory _swap_data = new SwapDataUnsupported embed;
    for (uint i = 0; i <= data.length - 1; i++) {
        _swap_data[i] = abi.decode(data[i], (SwapData));
    }

    uint256 balance_before = IERC20(_swap_data[0].token_in).balanceOf(address(this));

    RepayData memory _repay_data = RepayData(_swap_data, _swap_data[0].token_in, amount_in, liquidityPool, false);
    ILiquidity(liquidityPool).borrow(_swap_data[0].token_in, amount_in,
                                     abi.encodeWithSignature("receiveLoan(bytes)", abi.encode(_repay_data)));

    uint256 balance_after = IERC20(_swap_data[0].token_in).balanceOf(address(this));

    require(balance_after > balance_before, "No Profit!");
    return balance_after - balance_before;
}

它接收两个参数：

data: bytes类型的数组，用来存放兑换参数信息

amount_in: 需要闪电贷WETH的数量

首先，定义一个临时变量_swap_data，从data中解析出兑换参数的列表。

然后记录一下合约中WETH的数量。

然后定义一个临时变量_repay_data来存储兑换参数、还款信息(还款token、还款数量和还款地址)以及direct_repay标志。这里把direct_repay设为false，表示在获得闪电贷后执行套利操作，而不是直接还款。

接着调用liquidityPool的borrow()函数发起一笔闪电贷，并告诉它接收闪电贷的回调函数名称及参数类型(receiveLoan/bytes)，以及参数值(把_repay_data加密为一段bytes)

回调函数

发起闪电贷后，我们收到一笔WETH的贷款，并且回调函数receiveLoan()被调用:

// callback
function receiveLoan(bytes memory data) public {
    require(!lock, "Locked");
    RepayData memory _repay_data = abi.decode(data, (RepayData));

    if (_repay_data.direct_repay) {
        IERC20(_repay_data.repay_token).safeTransfer(_repay_data.recipient, _repay_data.repay_amount);
    } else {
        uint _length = _repay_data.swap_data.length;
        uint256 out_amount;

        for (uint i = 0; i <= _length - 1; i++) {
            out_amount = SwapBase(_repay_data.swap_data[i].pool,
                                  _repay_data.swap_data[i].function_id,
                                  i == 0 ? _repay_data.repay_amount : out_amount,
                                  _repay_data.swap_data[i].token_in_id,
                                  _repay_data.swap_data[i].token_out_id,
                                  _repay_data.swap_data[i].token_in,
                                  _repay_data.swap_data[i].token_out);
        }

                IERC20(_repay_data.repay_token).safeTransfer(_repay_data.recipient, _repay_data.repay_amount);
    }
}

首先，定义临时变量_repay_data，解析出data中的还款信息，如果direct_repay为true，直接还款(在Uniswap兑换的回调中用到)，否则进行如下的套利操作：

遍历_repay_data.swap_data数组，依次调用SwapBase()函数进行多笔兑换。最后进行还款操作。

检查利润

运行到这里，一笔闪电贷套利就完成了，最后我们在execute()函数的末尾要检查一下是否有利润：

uint256 balance_after = IERC20(_swap_data[0].token_in).balanceOf(address(this));

require(balance_after > balance_before, "No Profit!");
return balance_after - balance_before;

如果进行套利之后，合约中的WETH数量反而变少了，要进行revert回滚，因为不能允许一笔套利交易是亏损的。

如果有利润的话，最后返回利润的数值。这里为什么要返回利润值，不是多此一举吗？因为在生产环境下，在发出一笔交易前，我们需要先进行模拟，这里的模拟返回结果可以帮助我们进一步分析套利的成本、净利润等，从而调整gas价格策略，在后面的课程中会详细讲解。

测试

首先搭建mainet-fork测试环境(见第四讲):

ganache-cli --fork https://eth-mainnet.alchemyapi.io/v2/your_api_key

编译并部署合约:

truffle compile
truffle migrate

然后我们使用一个python脚本test_contract.py来进行测试。

开始测试前，建立一个python的虚拟环境:

sudo apt install python-virtualenv
cd ~/Projects/blockchainclass
virtualenv -p /usr/bin/python3.9 venv

安装web3.py

cd ~/Projects/blockchainclass
source venv/bin/activate
pip install web3

然后在test_contract.py中，填入合约部署地址，以及ganache-cli中生成的第一个账户地址和第一个密钥:

if __name__ == '__main__':
    test_contract(contract_address='',
                  account='',
                  private_key='')

最后运行:

python test_contract.py

可以看出，最后返回的结果是revert No Profit! 表明套利交易运行到最后，检查利润小于0，交易回滚了。

结语

以上我们在智能合约中实现了一个简单的双边套利操作，同样，我们可以继续拓展，实现三边、四边、五边..套利，并且可以在Curve和Uniswap以外的Dex中进行套利。

在本例中，Curve在前，Uniswap在后，所以我们用闪电贷获取初始资金，如果是Uniswap在前，Curve在后，就可以使用Uniswap的闪电兑功能，即先在Uniswap中发起一笔swap(),然后在回调函数中在Curve中进行兑换。

这些都可以作为思考题，留给有心的读者进行深入研究。要提醒的是，这里的示例代码只是做演示用，请在进行深入研究并开发出有利可图的策略之前，不要把示例代码部署到生产环境下。

下一讲，我们将会构建一个python脚本，实时监控以太坊上的套利机会，并调用智能合约进行套利。

欢迎来即刻App与我互动，即刻账号: 月影007

github:

GitHub - yueying007/blockchainclass

Contribute to yueying007/blockchainclass development by creating an account on GitHub.

https://github.com

Dex

Curve和Uniswap是以太坊上排名第一和第二的去中心化交易所(DEX)，它们分别都进行过几个版本的迭代升级，从最初的AMM(automatic market maker)发展到后来的 CLMM(concentrated liquidity market maker)模式，具体的swap算法不是本文的讨论重点，我们今天只通过接口来认识这两个协议。

Curve

首先来看Curve的一个池子：

Curve: USDT/WBTC/WETH Pool | Address: 0xD51a44d3...A1bfAAE46 | Etherscan

Contract: Verified | Balance: $16,643,787.06 across 1 Chain | Transactions: 44,685 | As at Oct-24-2025 09:47:20 PM (UTC)

https://etherscan.io

它提供了USDT/WETH/WBTC三种token的兑换，每个token都有一个唯一的编号(0/1/2)，编号和token的对应关系可以从合约的coins()方法获得。来看看它的接口:

interface ICurveCrypto {
    function exchange(uint256 from, uint256 to, uint256 from_amount, uint256 min_to_amount) external payable;
    function get_dy(uint256 from, uint256 to, uint256 from_amount) external view returns(uint256);
}

通过exchange()方法，实现两个token的兑换，参数分别表示：

from: 输入token的编号

to: 输出token的编号

from_amount: 输入token的数量

min_to_amount: 输出token的最小数量

通过get_dy()方法，获得给定from_amount下可以获得的输出token数量。

注意get_dy()的view关键字，表明这是一个只读函数，将来我们会它来计算token之间的兑换比例。

Uniswap

在来看一个UniswapV3的池子:

Uniswap V3: USDT | Address: 0x4e68Ccd3...3960dFa36 | Etherscan

Contract: Verified | Balance: $161,439,404.51 across 1 Chain | Transactions: 109 | As at Oct-24-2025 09:47:22 PM (UTC)

https://etherscan.io

它提供了WETH/USDT的兑换:

interface IUniswapV3Pair {
    function swap(
        address recipient,
        bool zeroForOne,
        int256 amountSpecified,
        uint160 sqrtPriceLimitX96,
        bytes calldata data
    ) external returns (int256 amount0, int256 amount1);
    function fee() external view returns(uint24);
}

通过swap()函数，实现两个token之间的兑换，这是一种闪电兑(flash swap)的模式，比如用WETH兑换USDT，它会先把USDT转给我的合约，然后在调用我的回调函数uniswapV3SwapCallback()，在回调函数中我把WETH还给它。参数分别表示：

recipient: 接收地址(我的合约)

zeroForOne: 标志位(用来决定兑换的方向)

amountSpecified: 输入token 的数量

sqrtPriceLimitX96: 限价范围

data: 回调信息

封装Curve

接下来我们封装一个函数实现Curve池子的兑换:

// CurveCrypto
function CurveCryptoExchange(address pool, uint256 token_in_id, uint256 token_out_id, address token_in,
    uint256 amount_in) internal {
    ApproveToken(token_in, pool, amount_in);
    ICurveCrypto(pool).exchange(token_in_id, token_out_id, amount_in, 0);
}

pool: Curve池子的地址

token_in_id: 输入token的编号

token_out_id: 输出token的编号

token_in: 输入token的地址

amount_in: 输入token的数量

注意在调用Curve池子的exchange()函数之前，我们需要先向Curve授权：

// approve
function ApproveToken(address token, address spender, uint256 amount) internal {
    uint256 alowance = IERC20(token).allowance(address(this), spender);
    if (alowance < amount) {
        IERC20(token).safeApprove(spender, 0);
        IERC20(token).safeApprove(spender, MAX_INT);
    }
}

Curve获得了我的合约的授权后，才可以通过transferFrom()方法，从我的合约把输入token转走。然后就可以调用exchange()进行兑换了。

封装Uniswap

接下来我们封装一个函数实现Uniswap的兑换:

// UniSwapV3
function UniswapV3Swap(address pool, address token_in, address token_out, uint256 amount_in) internal {
    bool zeroForOne = token_in < token_out;
    RepayData memory repay_data = RepayData(token_in, amount_in, pool);
    IUniswapV3Pair(pool).swap(address(this), zeroForOne, int256(amount_in),
        (zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1), abi.encode(repay_data));
}

首先通过zeroForOne标志确定兑换的方向。

然后定义一个RepayData结构来存储还款信息(还款token、还款数量和还款地址)，然后使用abi.encode()加密成一段bytes类型的data。然后调用Unisawp池子的swap()函数进行兑换。这里的address(this)表示我的合约地址。

回调

在Uniswap发起兑换后，它会把输出token转给我的合约，然后调用我的uniswapV3SwapCallback()函数:

function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata _data) public {
    receiveLoan(_data);
}

在函数的实现中，我们继续调用receiveLoan()，并在其中进行还款操作:

// callback
function receiveLoan(bytes memory data) public {
    require(!lock, "Locked");
    RepayData memory _repay_data = abi.decode(data, (RepayData));
    IERC20(_repay_data.repay_token).safeTransfer(_repay_data.recipient, _repay_data.repay_amount);
}

这里我们加了一个require条件要求合约是非锁定状态，来防止receiveLoan()被其他人恶意调用。

然后将还款信息解码，将token转给Uniswap池子。

注意在生产环境下尽量减少使用IERC20的low level call，因此我们把approve()和transfer()替换成了更加安全的safeApprove()和safeTransfer()。

封装Swapbase

为了方便，我们需要有一个统一的入口进行兑换，因此我们封装一个SwapBase()函数，通过function_id来识别兑换的协议:

// SwapBase
function SwapBase(address pool, uint256 function_id, uint256 amount_in, uint256 token_in_id, uint256 token_out_id,
    address token_in, address token_out) public returns(uint256) {
    uint256 balance = IERC20(token_out).balanceOf(address(this));
    if (function_id == 1) {
        UniswapV3Swap(pool, token_in, token_out, amount_in);
    } else if (function_id == 2) {
        CurveCryptoExchange(pool, token_in_id, token_out_id, token_in, amount_in);
    }
    return IERC20(token_out).balanceOf(address(this)) - balance;
}

根据function_id参数的不同，我们选择调用Curve还是Uniswap。同时还增加了一个返回值，用来返回最终得到的输出token的数量。

测试

下面就可以在truffle中进行编译和测试了(测试环境搭建参考上一讲)。

进入truffle控制台:

truffle console

定义一些基本地址:

WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
USDT = '0xdAC17F958D2ee523a2206206994597C13D831ec7';
Curvepool = '0xD51a44d3FaE010294C616388b506AcdA1bfAAE46';
Uniswappool = '0x4e68Ccd3E89f51C3074ca5072bbAC773960dFa36';

定义合约实例:

instance = await SimpleArbi.deployed();

向合约转入10个ETH，并将其中5个兑换为WETH:

instance.send(web3.utils.toWei('10', 'ether'));
instance.ETHtoWETH(web3.utils.toWei('5', 'ether'));

把合约锁打开:

instance.setLock(false);

通过Curve把1个WETH兑换为USDT:

instance.SwapBase(Curvepool, 2, web3.utils.toWei('1'), 2, 0, WETH, USDT);

检查一下合约中的USDT数量:

usdt = await instance.getTokenBalance(USDT, instance.address);
usdt.toString();

再把USDT全部换回WETH:

instance.SwapBase(Curvepool, 2, usdt, 0, 2, USDT, WETH);

通过Uniswap把1个WETH兑换为USDT:

instance.SwapBase(Uniswappool, 1, web3.utils.toWei('1'), 0, 0, WETH, USDT);

检查一下合约中的USDT数量:

usdt = await instance.getTokenBalance(USDT, instance.address);
usdt.toString();

再把USDT全部换回WETH:

instance.SwapBase(Uniswappool, 1, usdt, 0, 0, USDT, WETH);

结语

至此，我们在合约中分别使用Curve和Uniswap进行了Swap操作，下一讲我们继续把两个操作串联起来，实现一个套利操作。

欢迎来即刻App与我互动，即刻账号: 月影007

web3 provider

首先，我们需要从Alchemy.com申请一个免费的web3 provider：

Alchemy Dashboard

Whether you're a beginner developer, startup, web3 market leader, or a large enterprise, Alchemy makes multichain web3 development easy with reliable and scalable node infrastructure, enhanced APIs, and developer tools. Get started for free!

https://dashboard.alchemy.com

注册成功后，点击Create App，选择Ethereum Mainnet，然后在生成的App后面找到view key，将里面的http url保存到本地，以后我们与以太坊进行交互，都要通过这个http url来发送JSON-RPC请求。

Truffle

如果还没有安装Truffle：

npm install -g truffle

我们建立一个Deploy目录，在里面初始化一个Truffle工程：

mkdir ~/Projects/Deploy
cd ~/Projects/Deploy
truffle init

我们看到它自动生成了几个目录：

build: 存放编译好的智能合约abi

contracts: 存放智能合约的源代码

migrations: 存放部署脚本

首先我们打开truffle-config.js，做一些基本配置：

在networks中的development项，配置测试环境下的IP、端口以及network_id，同时把skipDryRun设置为true。

networks: {
 development: {
   host: "127.0.0.1",     
   port: 8545,            
   network_id: "*",       
   skipDryRun: true
 },
},

在compilers项，设置solidity的版本号(0.8.0)，optimizer enabled设置为true。

compilers: {
  solc: {
     version: "0.8.0",    
     settings: {         
      optimizer: {
        enabled: true,
        runs: 200
      },
    }
  }
}

然后，在migrations目录下，新建一个脚本2_deploy_contracts.js，通过这个脚本告诉truffle如何部署我们的合约:

var SimpleArbi = artifacts.require("../contracts/SimpleArbi.sol");module.exports = function(deployer, network, accounts) {
 deployer.deploy(SimpleArbi);
};

接下来，把SimpleArbi.sol文件拷贝到contracts目录下。

下面，我们开始进行编译:

cd ~/Projects/Deploy
truffle compile

当出现Compiled susccesfully using:…的提示时，就表示编译成功了。

部署

下面我们把编译好的智能合约部署在本地的测试环境下。

如果还没有安装Ganache-cli:

npm install -g ganache-cli

打开另外一个Terminal，建立一个以太坊主网的fork环境(后面的https://…是你刚才从Alchemy申请的http url)：

ganache-cli --fork https://eth-mainnet.alchemyapi.io/v2/你的api_key

它为我们自动建立了十个测试账户，每个里面有100ETH，在与合约交互时，它会默认使用第一个账户。

回到第一个Terminal中进行部署：

cd ~/Projects/Deploy
truffle migrate

部署成功后，它显示了交易哈希、合约地址等信息：

测试

下面，我们就可以进行测试了。

进入truffle控制台：

cd ~/Projects/Deploy
truffle console

先定义WETH的地址:

WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';

用instance代表合约的实例：

instance = await SimpleArbi.deployed();

查看一下合约的所有者是谁:

owner = await instance.getOwner()
owner

向合约转10个ETH:

instance.send(web3.utils.toWei('10', 'ether'))

调用合约的ETHtoWETH()函数，把5个ETH转换为WETH:

instance.ETHtoWETH(web3.utils.toWei('5', 'ether'))

调用合约的getTokenBalance()函数，检查一下合约中WETH的余额:

weth = await instance.getTokenBalance(WETH, instance.address);
weth.toString();

调用合约的turnOutToken()函数，把WETH转出到所有者的钱包里:

instance.turnOutToken(WETH, weth)

检查一下所有者钱包里的WETH数量:

weth = await instance.getTokenBalance(WETH, accounts[0]);
weth.toString();

最后，我们来测试一下flashLoan()函数，发起一笔闪电贷，:

result = await instance.flashLoan(WETH, web3.utils.toWei('100'))
result

交易成功，如果想看交易日志：

result.receipt.rawLogs

结语

至此，我们在本地的主网fork环境下，对SimpleArbi.sol合约的函数进行了测试，由于测试环境是完全fork主网的，所以就可以放心地部署到主网上面了。下一讲中，我们继续丰富合约代码，在其中加入Dex套利操作。

这一讲的代码在github上同步更新:

欢迎来即刻App与我互动，即刻账号: 月影007

在开始之前，你可以在本地建立一个目录，从github上下载代码，打开IDE，对照着代码学习。

mkdir ~/Projects
cd ~/Projects
git clone https://github.com/yueying007/blockchainclass.git

打开SimpleArbi.sol，我们来学习一下Solidity的基本用法。

SimpleArbi.sol

首先，在头部我们定义solidity的版本号：

pragma solidity 0.8.0;

接口

在执行一笔交易时，合约往往需要调用外部合约，因此需要定义外部合约的接口(interface)，最典型的是ERC20标准token的接口：

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function decimals() external view returns (uint8);
}

一个接口包含function关键字、函数名、参数列表、external关键字以及返回值类型。通过接口，合约可以与外部合约进行交互，而不需要知道外部合约具体的实现细节。

带view关键字的函数，表示只读函数，即只可以读取区块链的状态，而不可以改变状态，属于静态调用；不带view关键字的函数，可以进行改写状态变量、发送事件、转账ETH等等这些可以改变状态的调用，这类调用也可以称作一笔交易(transaction)。

在IERC20接口中，可以通过总供应量(totalSupply)、余额(balanceOf)、数位(decimals)等只读函数获取token的信息，也可以通过转账(transfer)、请求转账(transferFrom)、授权(approve)等函数发起交易。

下面看看WETH接口：

interface IWETH {
    function deposit() external payable;
    function withdraw(uint wad) external;
}

WETH(Wrapped Ether)，是一种将以太坊原生代币ETH与ERC20token互相转换的合约。在WETH接口中，定义了两个函数：

deposit: 将ETH转换为WETH

withdraw: 将WETH转换为ETH

由于要实现闪电贷，我们需要与KeeperDao的LiquidityPool合约交互，所以需要加上LiquidityPool的接口:

interface ILiquidity {
    function borrow(address _token, uint256 _amount, bytes calldata _data) external;
}

库

在写合约时经常需要用到一些库，比如最常用的SafeMath库。

在solidity中，通常会用uint256类型定义token的数量。uint256是一种非负整型变量，在进行加减乘数/取余/取模运算时，如果不小心就会溢出，所以在对uint256进行数学运算时，应当尽量用add/sub/mul/div来代替+-*/。

library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b <= a, errorMessage);
    uint256 c = a - b;

    return c;
}

合约

下面来到主体部分，合约(contract)。

solidity是一种面向对象的编程语言，用contract关键字定义一个合约，它类似于我们熟悉的类(class)，而部署一个合约相当于为这个类实例化一个对象。

一个类包含属性与方法，一个合约包含状态变量(state variable)与函数(function)。在函数内部定义的变量以及函数的参数称为局部变量(local variable)。状态变量与局部变量的区别在于，状态变量存储在区块链上，因此任何改写状态变量的操作都是一笔transaction，需要消耗gas，而局部变量只在内存中。因此，为了节省交易成本，我们应尽量少地去更改状态变量的值，而多用传参或者定义局部变量来完成计算。

首先我们定义一个结构体类型，用来存储借的token以及借的数量：

struct RepayData {
    address repay_token;
    uint256 repay_amount;
}

然后定义一些基本的地址：

address owner;
address liquidityPool = 0x4F868C1aa37fCf307ab38D215382e88FCA6275E2;
address borrowerProxy = 0x17a4C8F43cB407dD21f9885c5289E66E21bEcD9D;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;

然后来到构造函数：

constructor () public {
    owner = address(tx.origin);
}

构造函数只有在合约部署时被调用，在里面初始化一些状态变量。在这里，我们定义合约的所有者owner是部署合约这笔交易的源头(tx.origin)

修改器

修改器(modifier)是一种用来修改其它函数的函数，它可以包在其它函数外面，实现额外的功能。

我们定义一个onlyOwner()函数， 它要求函数的调用者(msg.sender)只能是合约的所有者(owner)。

modifier onlyOwner(){
    require(address(msg.sender) == owner, "No authority");
    _;
}

我们注意到这里有一个require函数，它类似于:

if (address(msg.sender) != owner) revert("No authority");

意思是如果不满足某个条件，则立即回滚到调用前的初始状态。如果一笔交易回滚，就相当于交易没有发生，这是一种原子操作，即要么成功，要么失败，没有中间状态。我们通常用require对函数的传参进行检查。记住，回滚的交易仍然会消耗gas。

fallback

在solidity 0.6.x版本以后，fallback函数分为两种：

fallback(): 当从外部调用此合约时，在合约中没有找到函数名，就会自动调用该函数

receive(): 用来接受空的外部调用(call())或者接收ETH

记住，如果不加上receive()，我们的合约是无法接收外部的ETH转账的：

receive() external payable {}

注：payable关键字：在调用函数的时候可以附带发送ETH。

访问权限

你可能注意到，无论是状态变量，还是函数，都有一个关键字来定义访问权限：

external: 只允许从合约外部访问

public: 既可以从合约外部访问，也可以从合约内部访问

internal: 只能从合约内部，或者从继承合约访问

private: 只能从合约内部访问，不能从继承合约访问

get/set

接下来我们定义一些函数用来读取信息或者发起交易：

// 返回合约的所有者
function getOwner() public view returns(address) {
    return owner;
}// 返回某个账户的某个token的余额
function getTokenBalance(address token, address account) public view returns(uint256) {
    return IERC20(token).balanceOf(account);
}// 从合约转出ETH
function turnOutETH(uint256 amount) public onlyOwner {
    payable(owner).transfer(amount);
}// 从合约转出token
function turnOutToken(address token, uint256 amount) public onlyOwner {
    IERC20(token).transfer(owner, amount);
}// WETH转换为ETH
function WETHToETH(uint256 amount) public onlyOwner {
    IWETH(WETH).withdraw(amount);
}// ETH转换为WETH
function ETHtoWETH(uint256 amount) public onlyOwner {
    IWETH(WETH).deposit{value:amount}();
}

注意，在get函数中，我们用view关键字表示只读。而在set函数中，我们加上了onlyOwner修改器，防止函数被所有者以外的人调用。

在任何时候编写合约，我都建议你加上turnOutETH和turnOutToken这两个函数，如果没加，合约里如果有ETH或者token，就会被永远锁在里面出不来了。

实现闪电贷

在实现闪电贷之前，我们先来熟悉一下KeerDao的合约：

LiquidityPool.sol

function borrow(address _token, uint256 _amount, bytes calldata _data) external nonReentrant whenNotPaused {
    require(address(kTokens[_token]) != address(0x0), "Token is not registered");
    uint256 initialBalance = borrowableBalance(_token);
    _transferOut(_msgSender(), _token, _amount);
    borrower.lend(_msgSender(), _data);
    uint256 finalBalance = borrowableBalance(_token);
    require(finalBalance >= initialBalance, "Borrower failed to return the borrowed funds");

    uint256 fee = finalBalance - initialBalance;
    uint256 poolFee = calculateFee(poolFeeInBips, fee);
    emit Borrowed(_msgSender(), _token, _amount, fee);
    _transferOut(feePool, _token, poolFee);
}

首先我通过调用LiquidityPool的borrow()发起一笔闪电贷，通过参数_token和_amount告诉它我要借什么token以及借多少。可以看到，在进行参数检查后，它会首先通过_transferOut()向我发送数量为_amount的_token，这时我就已经收到了这笔贷款。然后它会调用borrower的lend()。我们再来看看这个lend()函数是什么。

BorrowerProxy.sol

function lend(address _caller, bytes calldata _data) external payable  {
    require(msg.sender == liquidityPool, "BorrowerProxy: Caller is not the liquidity pool");
    (bool success,) = _caller.call{ value: msg.value }(_data);
    require(success, "BorrowerProxy: Borrower contract reverted during execution");
}

在lend()函数中，它首先检查调用方必须是LquidityPool，然后向_caller(就是我)发起一个回调call(_data)。要知道向其它合约发送call()就相当于调用其它合约的函数，而这里的_data是一段加密的bytes，包含了函数名和参数的信息。我收到回调后，会完成一系列套利操作，然后立即归还这笔贷款，因为接下来在borrow()函数中，它会检查贷款是否还清：

uint256 finalBalance = borrowableBalance(_token);
require(finalBalance >= initialBalance, "Borrower failed to return the borrowed funds");

如果没有还清，它会立即回滚，使整个交易失败。

此时这笔闪电贷的流程就明确了：

我调用LiquidityPool发起闪电贷 => LiquidityPool释放贷款 =>BorrowerProxy回调我=>我归还贷款

发起闪电贷

熟悉了流程之后，我们首先定义一个flashLoan函数发起闪电贷:

function flashLoan(address token, uint256 amount) public {
    RepayData memory _repay_data = RepayData(token, amount);
    ILiquidity(liquidityPool).borrow(token, amount,
        abi.encodeWithSelector(this.receiveLoan.selector, abi.encode(_repay_data)));
}

函数有两个参数，要借的token的地址(token)以及数量(amount)。然后定义一个局部变量_repay_data存储还款信息。我们用abi.encodeWithSelector把回调函数的名字以及还款信息加密成一串bytes类型的data，连同token,amount作为参数调用LiquidityPool的borrow()，发起一笔闪电贷。

回调函数

接下来我需要在合约里定义一个回调函数receiveLoan用来进行接收到贷款后的操作:

// callback
function receiveLoan(bytes memory data) public {
    require(msg.sender == borrowerProxy, "Not borrower");
    RepayData memory _repay_data = abi.decode(data, (RepayData));
    IERC20(_repay_data.repay_token).transfer(liquidityPool, _repay_data.repay_amount);
}

首先检查一下调用者必须是BorrorwerProxy合约，防止被其他人恶意调用。

然后将data解码，获得还款token和还款数量。

这里，我们先不做任何操作(以后需要在这里执行套利操作)，直接将token转给LiquidityPool，一笔闪电贷就完成了。

结语

至此，我们完成了一个简单的智能合约，实现了闪电贷的功能，在下一讲中，我会带你对这个合约进行测试。

欢迎来即刻App与我互动，即刻账号: 月影007

最大可提取价值 (Maximal Extractable Value, 简称MEV)

矿工 (或验证者、序列器) 在其生产的区块中通过其能力任意打包、排除或重新排序交易可以获得一定的利润，而 MEV 便是衡量该利润的一种度量。

MEV的详细解释请参考：

Maximal extractable value (MEV) | ethereum.org

An introduction to maximal extractable value (MEV)

https://ethereum.org

MEV有两个参与方，搜寻者(searcher)和矿工(miner)。

searcher搜索以太坊上面有利可图的交易(transaction)，例如Dex套利、三明治套利、清算交易、NFT minting等等，他们通过智能合约实现一笔复杂的交易，发送给到mem pool中，矿工将mem pool中的所有交易排序、打包、执行，searcher会将交易利润的一部分作为燃油费(gas fee)支付给矿工，矿工则根据燃油价(gas price)的大小决定在下一个区块中这些交易的顺序(indexing)。

注：gas_fee = gas_price * gas_use

还有一种特殊类型的searcher，他们不会自己去搜索机会，而是会观察mem pool中别的searcher提交的交易，把交易的签名者变成自己的钱包地址，以更高的gas price发送给矿工抢先成交，这种人统称为抢跑者(front runner，有办法可以避免自己的交易被front running，在后面的教程中会详细说明)。

gas price非常重要，因为它决定了交易的顺序。在以太坊黑暗森林里不只一个猎人，当一个机会出现时会有许多searcher发现并提交自己的交易，在下一个区块中如果你的交易没有排名第一，那么就会失败，因为利润已经被其它的searcher抢走了。这就不可避免的出现一场gas战争(gas war)，seacher会把交易利润的90%以上变成gas fee支付给矿工，以提高自己的排名。如果交易失败，矿工并不会把gas fee返还给searcher。最后造成恶性竞争，网络拥堵，而矿工成了这场战争的唯一赢家。

Flashbots

为了解决这种乱象，Flashbots应运而生。Flashbots提供这样一种服务，searcher不用把交易发送到mem pool，而是把一笔或者多笔交易捆绑(bundle)直接发送给矿工，如果成功开采下一个区块的矿工恰好也运行了Flashbots的客户端(Flashbots的哈希率目前大概是80%)，他就会按照如下规则执行所有bundle：

1. 模拟独立执行所有的bundle，记录每个bundle的price，bundle_price =矿工从bundle中获得的总收益/bundle的总gas_use，具体计算公式参考：https://docs.flashbots.net/flashbots-auction/searchers/advanced/bundle-pricing

2. 将bundle_price从高到低排序，按照顺序模拟执行一遍，把包含失败(revert)交易的bundle剔除掉，剩下成功的bundle按照既定顺序打包上链(include)，在一下个区块中，这些bundle会排在最前面

3. 如果一个bundle中包含多笔交易，只要其中一笔交易失败，整个bundle都不会被include，searcher也不会有任何损失(但是有5%的概率发生uncle bandit攻击，bundle会被泄露到mem pool中被其它矿工执行，如何避免被uncle，参考https://docs.flashbots.net/flashbots-protect/rpc/uncle-bandits)

由于交易不发送到mem pool，searcher就不用担心被抢跑，由于失败的交易不会上链，也不用担心交易失败造成的燃油费损失，避免了大规模gas war造成的网络拥堵。接下来，searcher只需关心如何提高自己的bundle_price获得排名第一的位置。

1. 提高矿工的总收益，即把交易利润中的更多比例变成矿工费

2. 减少gas_use，通过优化代码减少交易中gas使用量

支付矿工费有两种方式：

1. maxPriorityFeePerGas(tip price)，在EIP-1559中，gas_price = base_price + tip_price，其中base_price直接燃烧掉，tip_price支付给矿工。

2. 在智能合约中直接通过coinbase.transfer向矿工转账ETH

以上两种方式是完全等价的。

MEV套利

目前主流的mev套利有三种方式:

1. 三明治夹击(Sandwich Attack)

监控mem pool，发现其他用户提交的swap交易。比如有一笔交易，调用Uniswap Router合约，发送了一笔WETH兑换为USDT的交易，并设置了10%的滑点(slippage)，searcher会在它之前，提前在Uniswap的WETH/USDT池子中将WETH兑换为USDT，然后在它之后将USDT换回WETH，把三笔交易捆绑成一个bundle发送给矿工:

(1) searcher: WETH=>USDT

(2) 用户: WETH=>USDT

(3) searcher: USDT=>WETH

由于用户的兑换行为提高了USDT的价格，所以searcher会得到更多的WETH，除去本金以及交易成本，获得利润。

searcher会精心计算WETH的初始数量，保证用户的兑换结果恰好在10%滑点范围之内，因为如果超出了10%，用户的交易就会失败，从而整个bundle不会被矿工include。

2. 背后套利(BackRun)

监控mem pool，发现其它用户提交的swap交易。比如有一笔交易，调用Uniswap Router合约，发送了一笔WETH兑换为USDT的交易，由于数额巨大，该交易如果完成，将会显著抬高WETH/USDT池子中的USDT价格，和其它的Dex(比如Curve)出现价差。searcher会在它之后，在Uniswap和Curve之间进行套利，两笔交易捆绑成一个bundle发送给矿工：

(1) 用户: Uniswap WETH=>USDT

(2) searcher: Curve(WETH=>USDT) => Uniswap(USDT=>WETH)

由于Uniswap中USDT的价格比Curve中要高，所以searcher低买高卖，获得更多了WETH，除去本金以及交易成本，获得利润。

3. 普通套利

由于有些用户提交的swap交易是很隐蔽的(比如使用private transaction，或者通过dex aggregator进行)，所以背后套利的机会并不能全部被发现，会有一些漏网之鱼被mev searcher所忽略。这就导致在一个区块结束后，仍然会出现Dex之间的套利机会，这时searcher只要发现这些机会，同样可以把一笔套利交易捆绑成bundle发送给矿工，获得利润。

MEV套利的风险

理论上mev套利是无风险的，但是对于三明治夹击，有一种情况需要注意。

2021年4月，有人部署了一种称为沙氏门菌的token合约(Salmonella token)，在Uniswap中添加流动性，并发送一笔钓鱼swap交易，吸引机器人进行三明治夹击，机器人的第一笔交易用100个ETH买入token，第二笔交易卖出token失败，导致100个ETH留在池子中。

三明治机器人一般会通过两种措施防止这种瘸腿事故的发生：

1. 在发送bundle之前会先在测试环境模拟，如果模拟失败则不发送

2. 在第二笔卖出token的交易成功后再向矿工支付贿赂，这样如果交易失败，矿工不会收到贿赂，从而不会include bundle

但是这个Salmonella token有效地绕过了这两项防御措施，实施了对机器人的攻击，具体可参考：https://twitter.com/bertcmiller/status/1381296074086830091

闪电贷

在背后套利和普通套利中，由于套利是在一笔交易中完成的，所以可以通过闪电贷获得初始本金。

闪电贷(Flashloan)，是一种不需要抵押品的贷款，贷款和还款在同一笔交易内完成。

一些Defi协议会提供这种闪电贷，通过乐观转账(optimistic transafer)，先向用户发放贷款，在回调函数中用户实现套利交易并归还贷款，协议只收取一部分手续费(AAVE)，或者0手续费(KeeperDao, 提供WETH/DAI/USDC/renBTC四种token的闪电贷)。这样一笔套利交易就会变成：

(1) searcher: 从KeeprDao闪电贷WETH

(2) searcher: Curve(WETH=>USDT) => Uniswap(USDT=>WETH)

(3)searcher: 向KeeperDao归还WETH

闪电兑

有一些Dex提供闪电兑(Flashswap)，比如通过Uniswap把 USDT兑换为WETH，可以调用Uniswap池子的swap()函数，先通过乐观转账从池子中获得WETH，在回调函数中，用户实现套利交易并归还一定数量的USDT，这样相当于通过Uniswap完成了一次USDT=>WETH的兑换，并且账户中不需要有USDT作为本金。

searcher: Uniswap(USDT=>WETH) => Curve(WETH=>USDT)

结语

在解释了mev套利的基本概念之后，在下一讲我会带你编写一个简单的Solidity智能合约，实现闪电贷的功能。

欢迎来即刻App与我互动，即刻账号: 月影007

引言

大家好，我是月影007。

2021年5月，我从一家对冲基金辞职，在家做全职奶爸。我第一次打开以太坊浏览器etherscan.io，看着不断跳动的区块，以及一笔笔晦涩难懂的transaction，从此不小心闯入了区块链的世界，并被这里深深吸引。我带着强烈的好奇心，搜集区块链开发的技术文档，在Youtube上聆听国外技术大神的课程，一步步的从小白成长为开发者。我开发的以太坊套利机器人，帮助我在短短的半年时间内实现的财务自由，赚取了比过去十年还多的财富(将近500个ETH)。

回顾这一年，经历过大大小小的失败，也收获了许多惊喜，作为一个从quant转行crypto的程序员，我深知国人探索区块链开发是一件多么不容易的事情，几乎找不到系统的中文资料、中文视频，只有靠自己摸索。为了避免后来的人走弯路、踩坑，我决定将我在这个领域的经验分享出来，制作成一系列教程，以连载的方式更新，同时将源代码同步在Github上更新。

我会从易到难，带你一起开发一个可以用于生产的套利机器人。在学习完此教程之后，我希望你可以在我的基础上迭代更新，并实现盈利。即使你以后不想做套利，你在教程中掌握的技能也会帮助你快速建立一个DAPP，或者启动一个NFT项目。

教程分为三大块:

1. 以太坊套利机器人的原理及实现

2. Solidity智能合约的开发、测试及部署

3. 基于web3.py的开发、测试及部署

我会假设你是一个完全没有编程经验的小白，通过每一步的讲解，带你了解以太坊、DAPP、DEFI、DEX、ERC20、NFT等等知识。在开发的过程中用到的工具软件、第三方库以及第三方服务，我会在讲解的同时提示如何使用。

准备

首先，准备一台安装有Linux系统的电脑，教程中使用的是Ubuntu 18.04。

打开Terminal，更新软件:

sudo apt update
sudo apt upgrade

安装软件: Git/nodejs/Truffle/Ganache

sudo apt install git nodejs
npm install -g truffle
npm install -g ganache-cli

安装IDE(看个人喜好, vscode/pycharm都可以，教程中使用pycharm)

pycharm下载: https://www.jetbrains.com/zh-cn/pycharm/download/#section=linux

选择Community版本,下载到~/Downloads

cd Downloads
tar -xvzf pycharm-community-2022.1.tar.gz
cd ./pycharm-community-2020.1/bin
./pycharm.sh

在登录界面中点击Configure-Create Desktop Entry,创建桌面快捷方式

最后，请收藏以下两个网站：

gm - web3.py 7.14.0 documentation

Python Web3 SDK for Ethereum and EVM blockchains

https://web3py.readthedocs.io

准备工作完成了，下一讲我将会讲解以太坊套利的基本原理，并开始编写一个简单的Solidity智能合约。

欢迎来即刻App与我互动，即刻账号: 月影007