这节课中，我会带你使用Solidity编写一个简单的智能合约，实现闪电贷的功能。

在开始之前，你可以在本地建立一个目录，从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