# 浅析Compound

By [d1rrick](https://paragraph.com/@d1rrick) · 2022-08-29

---

#### 相关概念

##### 什么是Compound

Compound 是一个允许用户借贷代币的智能合约，它与你的银行类似，Compound 把你的钱借给借款人，并随着时间的推移赚取利息。但与银行不同的是，你的利息是从你存入 Compound 的智能合约后开始复利计算的。因为这是一个智能合约，整个流程中没有中间人，因此利息会比传统银行要高。

与 MakerDAO 类似，Compound 的贷款是通过**超额担保**确立的。借贷者将代币存入 Compound 中以增加他们的 **“借款能力”**，如果借贷者的借款能力低于 0，他们的抵押品将被出售以偿还债务。另外，每个资产的贷款利率是不同的，这根据资产的需求而决定。

##### 术语

*   **标的资产（Underlying Token）**：即借贷资产，比如 ETH、USDT、USDC、WBTC 等，目前 Compound II只开设了 17种标的资产。
    
*   **cToken**：也称为生息代币，是用户在 Compound 上存入资产的凭证。每一种标的资产都有对应的一种 cToken，比如，ETH 对应 cETH，USDT 对应 cUSDT，当用户向 Compound 存入 ETH 则会返回 cETH。取款时就可以用 cToken 换回标的资产。
    
*   **兑换率（Exchange Rate）**：cToken 与标的资产的兑换比例，比如 cETH 的兑换率为 0.02，即 1 个 cETH 可以兑换 0.02 个 ETH。兑换率会随着时间推移不断上涨，因此，持有 cToken 就等于不断生息，所以也才叫生息代币。计算公式为：exchangeRate = (totalCash + totalBorrows - totalReserves) / totalSupply
    
*   **抵押因子（Collateral Factor）**：每种标的资产都有一个抵押因子，代表用户抵押的资产价值对应可得到的借款的比率，即用来衡量可借额度的。取值范围 0-1，当为 0 时，表示该类资产不能作为抵押品去借贷其他资产。一般最高设为 0.75，比如 ETH，假如用户存入了 0.1 个 ETH 并开启作为抵押品，当时的 ETH 价值为 2000 美元，则可借额度为 0.1 \* 2000 \* 0.75 = 150 美元，可最多借出价值 150 美元的其他资产。
    

当用户存入**标的资产**后，Compound 会根据**兑换率**返回与标的资产相对应的 **cToken** 给到用户，作为一种存款凭证。当需要赎回存款时，将 cToken 还回去，Compound 会根据最新的兑换率计算出需要赎回的标的资产的数量并返还给用户。比如，用户存入 1 个 **ETH**，当时的兑换率为 0.1，则返回 1/0.1 = 10 个 **cETH**，等到赎回时，假设兑换率已经升到了 0.15，则那 10 个 cETH 可赎回 10\*0.15 = 1.5 个 ETH，多出的 0.5 个 ETH 就是利息所得。

当用户将存入的资产开启作为抵押品之后，则可以进行借款了。不过，不是所有资产都可以作为抵押品，比如 USDT 就不可以作为抵押品，其抵押因子为 0。ETH、DAI、USDC 的抵押因子都是 0.75，即 75%，表示价值 100 美元的抵押资产，可借额度为 75 美元，即最多可以借出价值 75 美元的数字资产。不过，不建议用完所有额度，不然，存在被清算的风险。

当用户的借款价值已经超过借款额度的时候，就可以被清算了。不过，智能合约没办法自动清算，所以需要外部的清算人调用智能合约的清算函数来执行清算。而为了激励第三方清算人来执行清算，就会有个清算激励，该激励由被清算人（即借款人）来承担。另外，清算人一般都是由程序化的清算服务来承担。

Compound 的清算模式属于**代还款清算**的方式，即清算人会帮借款人进行部分还款，并得到与还款资产价值同等的抵押资产，同时加上一定比例的清算激励，清算激励也是抵押资产。比如，借款人 A 有 100 USDT 的借款，而且抵押物为 ETH；那清算人 B 对 A 进行清算时，则需要帮 A 部分还款，目前 Compound 每次清算最多可代还款 50%，即 B 可以帮 A 还 50 USDT，假设清算激励为 0.05，那 B 将可以得到 A 的价值为 50 \* (1 + 0.05) = 52.5 USDT 的 ETH。

##### 利率模型

直线型：

![img](https://storage.googleapis.com/papyrus_images/b79771d84b7d3c74b7a827aa0fee6d97c73affb29b4c67364a1c65a648f8962d.png)

img

其中，黑色线为横轴，表示**使用率**，紫色线表示**借款利率**，绿色线表示**存款利率**。

Compound 早期的时候都是这种利率模型，目前，依然有少数几种资产保留着这种模型。

使用率即是资金的使用率，计算公式为：

    utilizationRate = borrows / (cash + borrows - reserves)
    

其中，borrows 表示借款额，cash 表示资金池余额，reserves 表示储备金。借款利率由使用率决定，存款利率由借款利率决定。

使用率本质上就是反映借贷供求关系的一个量化指标，使用率低说明存款的多，但借款的太少，即供给大于需求。这时候就需要鼓励用户多借款少存款，所以借款利率偏低，存款利率也偏低。而使用率高的时候则相反，借款利率和存款利率偏高，就能鼓励大家多存款少借款。

使用率偏高的话，那说明资金池里剩下的钱就比较少了，会面临资金池枯竭的风险。资金池枯竭的话，那存款用户就没资金可取，也没资金可借，这就可能会导致系统性风险了。一般资金使用率在 80% 以内比较安全。

拐点型：

![img](https://storage.googleapis.com/papyrus_images/958789a45a412a8c49fd72836a5111da55b526f2f65c888024d65667af197c13.png)

img

当资金使用率超过 80% 时斜率陡然剧增，超高的借款利率一般就能有效降低借款需求，而超高的存款利率则能鼓励大家提高供给，从而能有效降低整体的使用率，避免资金池枯竭。

目前，Compound 大部分资金池都是采用这种利率模型。

#### 代码分析

代码地址：[https://github.com/compound-finance/compound-protocol.git](https://github.com/compound-finance/compound-protocol.git)

代码结构

    .
    ├── BaseJumpRateModelV2.sol
    ├── CDaiDelegate.sol
    ├── CErc20Delegate.sol
    ├── CErc20Delegator.sol
    ├── CErc20Immutable.sol
    ├── CErc20.sol
    ├── CEther.sol
    ├── ComptrollerG7.sol
    ├── ComptrollerInterface.sol
    ├── Comptroller.sol
    ├── ComptrollerStorage.sol
    ├── CTokenInterfaces.sol
    ├── CToken.sol
    ├── DAIInterestRateModelV3.sol
    ├── EIP20Interface.sol
    ├── EIP20NonStandardInterface.sol
    ├── ErrorReporter.sol
    ├── ExponentialNoError.sol
    ├── Governance
    │   ├── Comp.sol
    │   ├── GovernorAlpha.sol
    │   ├── GovernorBravoDelegateG1.sol
    │   ├── GovernorBravoDelegateG2.sol
    │   ├── GovernorBravoDelegate.sol
    │   ├── GovernorBravoDelegator.sol
    │   └── GovernorBravoInterfaces.sol
    ├── InterestRateModel.sol
    ├── JumpRateModel.sol
    ├── JumpRateModelV2.sol
    ├── Lens
    │   └── CompoundLens.sol
    ├── Maximillion.sol
    ├── PriceOracle.sol
    ├── Reservoir.sol
    ├── SafeMath.sol
    ├── SimplePriceOracle.sol
    ├── Timelock.sol
    ├── Unitroller.sol
    └── WhitePaperInterestRateModel.sol
    

![img](https://storage.googleapis.com/papyrus_images/9e558d65e1083b2c6d28c305eaa6954aae2862085ca4b4307d2b5889247b990d.png)

img

合约文件虽然有点多，但涉及核心业务的其实可以分为四个模块：

*   **InterestRateModel**：利率模型的抽象合约，JumpRateModelV2、JumpRateModel、WhitePaperInterestRateModel 都是具体的利率模型实现。而 LegacyInterestRateModel 的代码和 InterestRateModel 相比，除了注释有些许不同，并没有其他区别。
    
*   **Comptroller**：审计合约，封装了全局使用的数据，以及很多业务检验功能。其入口合约为 Unitroller，也是一个代理合约。
    
*   **PriceOracle**：价格预言机合约，用来获取资产价格的。
    
*   **CToken**：cToken 代币的核心逻辑实现都在该合约中，属于抽象基类合约，没有构造函数，且定义了 3 个抽象函数。CEther 是 cETH 代币的入口合约，直接继承自 CToken。而 ERC20 的 cToken 入口则是 CErc20Delegator，这是一个代理合约，而实际实现合约为 CErc20Delegate 或 CCompLikeDelegate、CDaiDelegate 等。
    

下面，对每个模块再分别深入讲解。

**InterestRateModel**

**_直线型_**

    contract WhitePaperInterestRateModel is InterestRateModel {
        event NewInterestParams(uint baseRatePerBlock, uint multiplierPerBlock);
    
        uint256 private constant BASE = 1e18;
    
        /**
         * @notice The approximate number of blocks per year that is assumed by the interest rate model
         */
        uint public constant blocksPerYear = 2102400;
    
        /**
         * @notice The multiplier of utilization rate that gives the slope of the interest rate
         */
        uint public multiplierPerBlock;
    
        /**
         * @notice The base interest rate which is the y-intercept when utilization rate is 0
         */
        uint public baseRatePerBlock;
    
        /**
         * @notice Construct an interest rate model
         * @param baseRatePerYear The approximate target base APR, as a mantissa (scaled by BASE)
         * @param multiplierPerYear The rate of increase in interest rate wrt utilization (scaled by BASE)
         */
        constructor(uint baseRatePerYear, uint multiplierPerYear) public {
            baseRatePerBlock = baseRatePerYear / blocksPerYear;
            multiplierPerBlock = multiplierPerYear / blocksPerYear;
    
            emit NewInterestParams(baseRatePerBlock, multiplierPerBlock);
        }
    
        /**
         * @notice Calculates the utilization rate of the market: `borrows / (cash + borrows - reserves)`
         * @param cash The amount of cash in the market
         * @param borrows The amount of borrows in the market
         * @param reserves The amount of reserves in the market (currently unused)
         * @return The utilization rate as a mantissa between [0, BASE]
         */
        function utilizationRate(uint cash, uint borrows, uint reserves) public pure returns (uint) {
            // Utilization rate is 0 when there are no borrows
            if (borrows == 0) {
                return 0;
            }
    
            return borrows * BASE / (cash + borrows - reserves);
        }
    
        /**
         * @notice Calculates the current borrow rate per block, with the error code expected by the market
         * @param cash The amount of cash in the market
         * @param borrows The amount of borrows in the market
         * @param reserves The amount of reserves in the market
         * @return The borrow rate percentage per block as a mantissa (scaled by BASE)
         */
        function getBorrowRate(uint cash, uint borrows, uint reserves) override public view returns (uint) {
            uint ur = utilizationRate(cash, borrows, reserves);
            return (ur * multiplierPerBlock / BASE) + baseRatePerBlock;
        }
    
        /**
         * @notice Calculates the current supply rate per block
         * @param cash The amount of cash in the market
         * @param borrows The amount of borrows in the market
         * @param reserves The amount of reserves in the market
         * @param reserveFactorMantissa The current reserve factor for the market
         * @return The supply rate percentage per block as a mantissa (scaled by BASE)
         */
        function getSupplyRate(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) override public view returns (uint) {
            uint oneMinusReserveFactor = BASE - reserveFactorMantissa;
            uint borrowRate = getBorrowRate(cash, borrows, reserves);
            uint rateToPool = borrowRate * oneMinusReserveFactor / BASE;
            return utilizationRate(cash, borrows, reserves) * rateToPool / BASE;
        }
    }
    

所谓的直线，其实是借款利率的，其计算公式为：

    y = k*x + b
    

y 即 y 轴的值，即借款利率值，x 即 x 轴的值，表示资金使用率，k 为斜率，b 则是 x 为 0 时的起点值。

理解了这条公式之后，我们再来看代码就会很好理解那些值的含义了。先来看看构造函数：

    constructor(uint baseRatePerYear, uint multiplierPerYear) public {
        baseRatePerBlock = baseRatePerYear.div(blocksPerYear);
        multiplierPerBlock = multiplierPerYear.div(blocksPerYear);
    
        emit NewInterestParams(baseRatePerBlock, multiplierPerBlock);
    }
    

构造函数有两个入参：

*   **baseRatePerYear**：基准年利率，其实就是公式中的 b 值
    
*   **multiplierPerYear**：其实就是斜率 k 值
    

构造函数的实现中，_blocksPerYear_ 是一个常量值，表示一年内的区块数 2102400，是按照每 15 秒出一个区块计算得出的。将两个入参分别除以 _blocksPerYear_，就分别得到了区块级别的基准利率和区块斜率。

那公式中的 b 值和 k 值都初始化好了，x 值即资金使用率则是动态计算的，计算公式为：

    资金使用率 = 总借款 / (资金池余额 + 总借款 - 储备金)
    utilizationRate = borrows / (cash + borrows - reserves)
    

其代码实现如下：

    function utilizationRate(uint cash, uint borrows, uint reserves) public pure returns (uint) {
        // Utilization rate is 0 when there are no borrows
        if (borrows == 0) {
          return 0;
        }
    
        return borrows.mul(BASE).div(cash.add(borrows).sub(reserves));
    }
    

其中，mul(1e18) 是为了将结果值扩展为对应的精度整数。

那么，借款利率的实现也很容易理解了，代码如下：

    function getBorrowRate(uint cash, uint borrows, uint reserves) public view returns (uint) {
        uint ur = utilizationRate(cash, borrows, reserves);
        return ur.mul(multiplierPerBlock).div(BASE).add(baseRatePerBlock);
    }
    

其中，div(BASE) 则是因为 ur 和 multiplierPerBlock 本身都已经扩为高精度整数了，相乘之后精度变成 36 了，所以再除以 1e18 就可以把精度降回 18。

最后，存款利率又是如何计算的呢？请看代码：

    function getSupplyRate(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) public view returns (uint) {
        uint oneMinusReserveFactor = uint(BASE).sub(reserveFactorMantissa);
        uint borrowRate = getBorrowRate(cash, borrows, reserves);
        uint rateToPool = borrowRate.mul(oneMinusReserveFactor).div(BASE);
        return utilizationRate(cash, borrows, reserves).mul(rateToPool).div(BASE);
    }
    

整理一下就可得到计算公式为：

    存款利率 = 资金使用率 * 借款利率 *（1 - 储备金率）
    supplyRate = utilizationRate * borrowRate * (1 - reserveFactor)
    

至此，直线型的利率模型，合约内容就这么多了，还是非常容易理解的。

**_拐点型_**

    /**
      * @title Compound's JumpRateModel Contract V2 for V2 cTokens
      * @author Arr00
      * @notice Supports only for V2 cTokens
      */
    contract JumpRateModelV2 is InterestRateModel, BaseJumpRateModelV2  {
    
        /**
         * @notice Calculates the current borrow rate per block
         * @param cash The amount of cash in the market
         * @param borrows The amount of borrows in the market
         * @param reserves The amount of reserves in the market
         * @return The borrow rate percentage per block as a mantissa (scaled by 1e18)
         */
        function getBorrowRate(uint cash, uint borrows, uint reserves) override external view returns (uint) {
            return getBorrowRateInternal(cash, borrows, reserves);
        }
    
        constructor(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink_, address owner_)
    
        BaseJumpRateModelV2(baseRatePerYear,multiplierPerYear,jumpMultiplierPerYear,kink_,owner_) public {}
    }
    

    /**
      * @title Logic for Compound's JumpRateModel Contract V2.
      * @author Compound (modified by Dharma Labs, refactored by Arr00)
      * @notice Version 2 modifies Version 1 by enabling updateable parameters.
      */
    abstract contract BaseJumpRateModelV2 is InterestRateModel {
        event NewInterestParams(uint baseRatePerBlock, uint multiplierPerBlock, uint jumpMultiplierPerBlock, uint kink);
    
        uint256 private constant BASE = 1e18;
    
        /**
         * @notice The address of the owner, i.e. the Timelock contract, which can update parameters directly
         */
        address public owner;
    
        /**
         * @notice The approximate number of blocks per year that is assumed by the interest rate model
         */
        uint public constant blocksPerYear = 2102400;
    
        /**
         * @notice The multiplier of utilization rate that gives the slope of the interest rate
         */
        uint public multiplierPerBlock;
    
        /**
         * @notice The base interest rate which is the y-intercept when utilization rate is 0
         */
        uint public baseRatePerBlock;
    
        /**
         * @notice The multiplierPerBlock after hitting a specified utilization point
         */
        uint public jumpMultiplierPerBlock;
    
        /**
         * @notice The utilization point at which the jump multiplier is applied
         */
        uint public kink;
    
        /**
         * @notice Construct an interest rate model
         * @param baseRatePerYear The approximate target base APR, as a mantissa (scaled by BASE)
         * @param multiplierPerYear The rate of increase in interest rate wrt utilization (scaled by BASE)
         * @param jumpMultiplierPerYear The multiplierPerBlock after hitting a specified utilization point
         * @param kink_ The utilization point at which the jump multiplier is applied
         * @param owner_ The address of the owner, i.e. the Timelock contract (which has the ability to update parameters directly)
         */
        constructor(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink_, address owner_) internal {
            owner = owner_;
    
            updateJumpRateModelInternal(baseRatePerYear,  multiplierPerYear, jumpMultiplierPerYear, kink_);
        }
    
        /**
         * @notice Update the parameters of the interest rate model (only callable by owner, i.e. Timelock)
         * @param baseRatePerYear The approximate target base APR, as a mantissa (scaled by BASE)
         * @param multiplierPerYear The rate of increase in interest rate wrt utilization (scaled by BASE)
         * @param jumpMultiplierPerYear The multiplierPerBlock after hitting a specified utilization point
         * @param kink_ The utilization point at which the jump multiplier is applied
         */
        function updateJumpRateModel(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink_) virtual external {
            require(msg.sender == owner, "only the owner may call this function.");
    
            updateJumpRateModelInternal(baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_);
        }
    
        /**
         * @notice Calculates the utilization rate of the market: `borrows / (cash + borrows - reserves)`
         * @param cash The amount of cash in the market
         * @param borrows The amount of borrows in the market
         * @param reserves The amount of reserves in the market (currently unused)
         * @return The utilization rate as a mantissa between [0, BASE]
         */
        function utilizationRate(uint cash, uint borrows, uint reserves) public pure returns (uint) {
            // Utilization rate is 0 when there are no borrows
            if (borrows == 0) {
                return 0;
            }
    
            return borrows * BASE / (cash + borrows - reserves);
        }
    
        /**
         * @notice Calculates the current borrow rate per block, with the error code expected by the market
         * @param cash The amount of cash in the market
         * @param borrows The amount of borrows in the market
         * @param reserves The amount of reserves in the market
         * @return The borrow rate percentage per block as a mantissa (scaled by BASE)
         */
        function getBorrowRateInternal(uint cash, uint borrows, uint reserves) internal view returns (uint) {
            uint util = utilizationRate(cash, borrows, reserves);
    
            if (util <= kink) {
                return ((util * multiplierPerBlock) / BASE) + baseRatePerBlock;
            } else {
                uint normalRate = ((kink * multiplierPerBlock) / BASE) + baseRatePerBlock;
                uint excessUtil = util - kink;
                return ((excessUtil * jumpMultiplierPerBlock) / BASE) + normalRate;
            }
        }
    
        /**
         * @notice Calculates the current supply rate per block
         * @param cash The amount of cash in the market
         * @param borrows The amount of borrows in the market
         * @param reserves The amount of reserves in the market
         * @param reserveFactorMantissa The current reserve factor for the market
         * @return The supply rate percentage per block as a mantissa (scaled by BASE)
         */
        function getSupplyRate(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) virtual override public view returns (uint) {
            uint oneMinusReserveFactor = BASE - reserveFactorMantissa;
            uint borrowRate = getBorrowRateInternal(cash, borrows, reserves);
            uint rateToPool = borrowRate * oneMinusReserveFactor / BASE;
            return utilizationRate(cash, borrows, reserves) * rateToPool / BASE;
        }
    
        /**
         * @notice Internal function to update the parameters of the interest rate model
         * @param baseRatePerYear The approximate target base APR, as a mantissa (scaled by BASE)
         * @param multiplierPerYear The rate of increase in interest rate wrt utilization (scaled by BASE)
         * @param jumpMultiplierPerYear The multiplierPerBlock after hitting a specified utilization point
         * @param kink_ The utilization point at which the jump multiplier is applied
         */
        function updateJumpRateModelInternal(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink_) internal {
            baseRatePerBlock = baseRatePerYear / blocksPerYear;
            multiplierPerBlock = (multiplierPerYear * BASE) / (blocksPerYear * kink_);
            jumpMultiplierPerBlock = jumpMultiplierPerYear / blocksPerYear;
            kink = kink_;
    
            emit NewInterestParams(baseRatePerBlock, multiplierPerBlock, jumpMultiplierPerBlock, kink);
        }
    }
    

拐点型主要有过两个版本的实现，**JumpRateModel** 和 **JumpRateModelV2**，目前，曾经使用 _JumpRateModel_ 的都已经升级为 _JumpRateModelV2_，所以我们就直接研究 JumpRateModelV2 即可。

回想下拐点型的图形，基本特征就是在拐点前的借款利率是一条直线，拐点后则是另一条斜率高得多的直线。

资金使用率没超过拐点值时，利率公式和直线型的一样：

    y = k*x + b
    

而超过拐点之后，则利率公式将变成：

    y = k2*(x - p) + (k*p + b)
    

其中，k2 表示拐点后的直线的斜率，p 则表示拐点的 x 轴的值。因此，需要初始化的参数有 4 个：**b、k、k2、p**，分别对应了构造函数中的几个入参：**baseRatePerYear、multiplierPerYear、jumpMultiplierPerYear、kink**。而几个 PerYear 入参对应的就有几个 PerBlock 变量，和前面一样，就不重复说明了。

那理解了上面的计算公式，我们来看看获取借款利率的代码实现：

    function getBorrowRateInternal(uint cash, uint borrows, uint reserves) internal view returns (uint) {
        uint util = utilizationRate(cash, borrows, reserves);
    
        if (util <= kink) {
              return util.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);
        } else {
            uint normalRate = kink.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);
            uint excessUtil = util.sub(kink);
            return excessUtil.mul(jumpMultiplierPerBlock).div(1e18).add(normalRate);
        }
    }
    

而存款利率的计算公式则和直线型的一样，没有变化。因为存款利率是随着借款利率而变的，所以斜率其实也跟随着借款利率而变化。

**CToken**

![image20210801093442358.png](https://storage.googleapis.com/papyrus_images/ddcb24ce5306839775688de66eab3a1a5e24d7acf43201f5548bf62977e605ee.png)

image20210801093442358.png

外部账户与CErc20Delegator合约做交互，执行逻辑在CErc20Delegate合约

CToken 合约管理着 cToken 代币，也管理着借贷的资金池，所以 CToken 的核心地位毋庸置疑。

CToken 合约只是个基类合约，没有构造函数，且还声明了几个抽象函数，由上层合约来实现。上层合约主要分两类，一类是用来处理 ETH 的 **CEther** 合约，该合约也是用户交互的入口合约；一类是用来处理 ERC20 的 **CErc20** 合约。在早期版本中，CErc20 也是用户交互的入口合约，但后来做了调整，CErc20 移除了构造函数，改为了初始化函数，增加了 CErc20Delegate 作为其上层合约，而且还增加了 CErc20Delegator 来代理 CToken，作为 cToken 的入口合约。

简而言之，**ETH** 的 cToken 交互入口是 **CEther** 合约，仅此一份；而 **ERC20** 的 cToken 交互入口则是 **CErc20Delegator** 合约，每种 ERC20 资产都各有一份入口合约。

    /**
     * @title Compound's CToken Contract
     * @notice Abstract base for CTokens
     * @author Compound
     */
    abstract contract CToken is CTokenInterface, ExponentialNoError, TokenErrorReporter {
        /**
         * @notice Initialize the money market
         * @param comptroller_ The address of the Comptroller
         * @param interestRateModel_ The address of the interest rate model
         * @param initialExchangeRateMantissa_ The initial exchange rate, scaled by 1e18
         * @param name_ EIP-20 name of this token
         * @param symbol_ EIP-20 symbol of this token
         * @param decimals_ EIP-20 decimal precision of this token
         */
              
        function initialize(ComptrollerInterface comptroller_,
                            InterestRateModel interestRateModel_,
                            uint initialExchangeRateMantissa_,
                            string memory name_,
                            string memory symbol_,
                            uint8 decimals_) public {
            require(msg.sender == admin, "only admin may initialize the market");
            require(accrualBlockNumber == 0 && borrowIndex == 0, "market may only be initialized once");
    
            // Set initial exchange rate
            initialExchangeRateMantissa = initialExchangeRateMantissa_;
            require(initialExchangeRateMantissa > 0, "initial exchange rate must be greater than zero.");
    
            // Set the comptroller
            uint err = _setComptroller(comptroller_);
            require(err == NO_ERROR, "setting comptroller failed");
    
            // Initialize block number and borrow index (block number mocks depend on comptroller being set)
            accrualBlockNumber = getBlockNumber();
            borrowIndex = mantissaOne;
    
            // Set the interest rate model (depends on block number / borrow index)
            err = _setInterestRateModelFresh(interestRateModel_);
            require(err == NO_ERROR, "setting interest rate model failed");
    
            name = name_;
            symbol = symbol_;
            decimals = decimals_;
    
            // The counter starts true to prevent changing it from zero to non-zero (i.e. smaller cost/refund)
            _notEntered = true;
        }
    
        /**
         * @notice Transfer `tokens` tokens from `src` to `dst` by `spender`
         * @dev Called by both `transfer` and `transferFrom` internally
         * @param spender The address of the account performing the transfer
         * @param src The address of the source account
         * @param dst The address of the destination account
         * @param tokens The number of tokens to transfer
         * @return 0 if the transfer succeeded, else revert
         */
        function transferTokens(address spender, address src, address dst, uint tokens) internal returns (uint) {
            /* Fail if transfer not allowed */
            uint allowed = comptroller.transferAllowed(address(this), src, dst, tokens);
            if (allowed != 0) {
                revert TransferComptrollerRejection(allowed);
            }
    
            /* Do not allow self-transfers */
            if (src == dst) {
                revert TransferNotAllowed();
            }
    
            /* Get the allowance, infinite for the account owner */
            uint startingAllowance = 0;
            if (spender == src) {
                startingAllowance = type(uint).max;
            } else {
                startingAllowance = transferAllowances[src][spender];
            }
    
            /* Do the calculations, checking for {under,over}flow */
            uint allowanceNew = startingAllowance - tokens;
            uint srcTokensNew = accountTokens[src] - tokens;
            uint dstTokensNew = accountTokens[dst] + tokens;
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            accountTokens[src] = srcTokensNew;
            accountTokens[dst] = dstTokensNew;
    
            /* Eat some of the allowance (if necessary) */
            if (startingAllowance != type(uint).max) {
                transferAllowances[src][spender] = allowanceNew;
            }
    
            /* We emit a Transfer event */
            emit Transfer(src, dst, tokens);
    
            // unused function
            // comptroller.transferVerify(address(this), src, dst, tokens);
    
            return NO_ERROR;
        }
    
        /**
         * @notice Transfer `amount` tokens from `msg.sender` to `dst`
         * @param dst The address of the destination account
         * @param amount The number of tokens to transfer
         * @return Whether or not the transfer succeeded
         */
        function transfer(address dst, uint256 amount) override external nonReentrant returns (bool) {
            return transferTokens(msg.sender, msg.sender, dst, amount) == NO_ERROR;
        }
    
        /**
         * @notice Transfer `amount` tokens from `src` to `dst`
         * @param src The address of the source account
         * @param dst The address of the destination account
         * @param amount The number of tokens to transfer
         * @return Whether or not the transfer succeeded
         */
        function transferFrom(address src, address dst, uint256 amount) override external nonReentrant returns (bool) {
            return transferTokens(msg.sender, src, dst, amount) == NO_ERROR;
        }
    
        /**
         * @notice Approve `spender` to transfer up to `amount` from `src`
         * @dev This will overwrite the approval amount for `spender`
         *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
         * @param spender The address of the account which may transfer tokens
         * @param amount The number of tokens that are approved (uint256.max means infinite)
         * @return Whether or not the approval succeeded
         */
        function approve(address spender, uint256 amount) override external returns (bool) {
            address src = msg.sender;
            transferAllowances[src][spender] = amount;
            emit Approval(src, spender, amount);
            return true;
        }
    
        /**
         * @notice Get the current allowance from `owner` for `spender`
         * @param owner The address of the account which owns the tokens to be spent
         * @param spender The address of the account which may transfer tokens
         * @return The number of tokens allowed to be spent (-1 means infinite)
         */
        function allowance(address owner, address spender) override external view returns (uint256) {
            return transferAllowances[owner][spender];
        }
    
        /**
         * @notice Get the token balance of the `owner`
         * @param owner The address of the account to query
         * @return The number of tokens owned by `owner`
         */
        function balanceOf(address owner) override external view returns (uint256) {
            return accountTokens[owner];
        }
    
        /**
         * @notice Get the underlying balance of the `owner`
         * @dev This also accrues interest in a transaction
         * @param owner The address of the account to query
         * @return The amount of underlying owned by `owner`
         */
        function balanceOfUnderlying(address owner) override external returns (uint) {
            Exp memory exchangeRate = Exp({mantissa: exchangeRateCurrent()});
            return mul_ScalarTruncate(exchangeRate, accountTokens[owner]);
        }
    
        /**
         * @notice Get a snapshot of the account's balances, and the cached exchange rate
         * @dev This is used by comptroller to more efficiently perform liquidity checks.
         * @param account Address of the account to snapshot
         * @return (possible error, token balance, borrow balance, exchange rate mantissa)
         */
        function getAccountSnapshot(address account) override external view returns (uint, uint, uint, uint) {
            return (
                NO_ERROR,
                accountTokens[account],
                borrowBalanceStoredInternal(account),
                exchangeRateStoredInternal()
            );
        }
    
        /**
         * @dev Function to simply retrieve block number
         *  This exists mainly for inheriting test contracts to stub this result.
         */
        function getBlockNumber() virtual internal view returns (uint) {
            return block.number;
        }
    
        /**
         * @notice Returns the current per-block borrow interest rate for this cToken
         * @return The borrow interest rate per block, scaled by 1e18
         */
        function borrowRatePerBlock() override external view returns (uint) {
            return interestRateModel.getBorrowRate(getCashPrior(), totalBorrows, totalReserves);
        }
    
        /**
         * @notice Returns the current per-block supply interest rate for this cToken
         * @return The supply interest rate per block, scaled by 1e18
         */
        function supplyRatePerBlock() override external view returns (uint) {
            return interestRateModel.getSupplyRate(getCashPrior(), totalBorrows, totalReserves, reserveFactorMantissa);
        }
    
        /**
         * @notice Returns the current total borrows plus accrued interest
         * @return The total borrows with interest
         */
        function totalBorrowsCurrent() override external nonReentrant returns (uint) {
            accrueInterest();
            return totalBorrows;
        }
    
        /**
         * @notice Accrue interest to updated borrowIndex and then calculate account's borrow balance using the updated borrowIndex
         * @param account The address whose balance should be calculated after updating borrowIndex
         * @return The calculated balance
         */
        function borrowBalanceCurrent(address account) override external nonReentrant returns (uint) {
            accrueInterest();
            return borrowBalanceStored(account);
        }
    
        /**
         * @notice Return the borrow balance of account based on stored data
         * @param account The address whose balance should be calculated
         * @return The calculated balance
         */
        function borrowBalanceStored(address account) override public view returns (uint) {
            return borrowBalanceStoredInternal(account);
        }
    
        /**
         * @notice Return the borrow balance of account based on stored data
         * @param account The address whose balance should be calculated
         * @return (error code, the calculated balance or 0 if error code is non-zero)
         */
        function borrowBalanceStoredInternal(address account) internal view returns (uint) {
            /* Get borrowBalance and borrowIndex */
            BorrowSnapshot storage borrowSnapshot = accountBorrows[account];
    
            /* If borrowBalance = 0 then borrowIndex is likely also 0.
             * Rather than failing the calculation with a division by 0, we immediately return 0 in this case.
             */
            if (borrowSnapshot.principal == 0) {
                return 0;
            }
    
            /* Calculate new borrow balance using the interest index:
             *  recentBorrowBalance = borrower.borrowBalance * market.borrowIndex / borrower.borrowIndex
             */
            uint principalTimesIndex = borrowSnapshot.principal * borrowIndex;
            return principalTimesIndex / borrowSnapshot.interestIndex;
        }
    
        /**
         * @notice Accrue interest then return the up-to-date exchange rate
         * @return Calculated exchange rate scaled by 1e18
         */
        function exchangeRateCurrent() override public nonReentrant returns (uint) {
            accrueInterest();
            return exchangeRateStored();
        }
    
        /**
         * @notice Calculates the exchange rate from the underlying to the CToken
         * @dev This function does not accrue interest before calculating the exchange rate
         * @return Calculated exchange rate scaled by 1e18
         */
        function exchangeRateStored() override public view returns (uint) {
            return exchangeRateStoredInternal();
        }
    
        /**
         * @notice Calculates the exchange rate from the underlying to the CToken
         * @dev This function does not accrue interest before calculating the exchange rate
         * @return calculated exchange rate scaled by 1e18
         */
        function exchangeRateStoredInternal() virtual internal view returns (uint) {
            uint _totalSupply = totalSupply;
            if (_totalSupply == 0) {
                /*
                 * If there are no tokens minted:
                 *  exchangeRate = initialExchangeRate
                 */
                return initialExchangeRateMantissa;
            } else {
                /*
                 * Otherwise:
                 *  exchangeRate = (totalCash + totalBorrows - totalReserves) / totalSupply
                 */
                uint totalCash = getCashPrior();
                uint cashPlusBorrowsMinusReserves = totalCash + totalBorrows - totalReserves;
                uint exchangeRate = cashPlusBorrowsMinusReserves * expScale / _totalSupply;
    
                return exchangeRate;
            }
        }
    
        /**
         * @notice Get cash balance of this cToken in the underlying asset
         * @return The quantity of underlying asset owned by this contract
         */
        function getCash() override external view returns (uint) {
            return getCashPrior();
        }
    
        /**
         * @notice Applies accrued interest to total borrows and reserves
         * @dev This calculates interest accrued from the last checkpointed block
         *   up to the current block and writes new checkpoint to storage.
         */
        function accrueInterest() virtual override public returns (uint) {
            /* Remember the initial block number */
            uint currentBlockNumber = getBlockNumber();
            uint accrualBlockNumberPrior = accrualBlockNumber;
    
            /* Short-circuit accumulating 0 interest */
            if (accrualBlockNumberPrior == currentBlockNumber) {
                return NO_ERROR;
            }
    
            /* Read the previous values out of storage */
            uint cashPrior = getCashPrior();
            uint borrowsPrior = totalBorrows;
            uint reservesPrior = totalReserves;
            uint borrowIndexPrior = borrowIndex;
    
            /* Calculate the current borrow interest rate */
            uint borrowRateMantissa = interestRateModel.getBorrowRate(cashPrior, borrowsPrior, reservesPrior);
            require(borrowRateMantissa <= borrowRateMaxMantissa, "borrow rate is absurdly high");
    
            /* Calculate the number of blocks elapsed since the last accrual */
            uint blockDelta = currentBlockNumber - accrualBlockNumberPrior;
    
            /*
             * Calculate the interest accumulated into borrows and reserves and the new index:
             *  simpleInterestFactor = borrowRate * blockDelta
             *  interestAccumulated = simpleInterestFactor * totalBorrows
             *  totalBorrowsNew = interestAccumulated + totalBorrows
             *  totalReservesNew = interestAccumulated * reserveFactor + totalReserves
             *  borrowIndexNew = simpleInterestFactor * borrowIndex + borrowIndex
             */
    
            Exp memory simpleInterestFactor = mul_(Exp({mantissa: borrowRateMantissa}), blockDelta);
            uint interestAccumulated = mul_ScalarTruncate(simpleInterestFactor, borrowsPrior);
            uint totalBorrowsNew = interestAccumulated + borrowsPrior;
            uint totalReservesNew = mul_ScalarTruncateAddUInt(Exp({mantissa: reserveFactorMantissa}), interestAccumulated, reservesPrior);
            uint borrowIndexNew = mul_ScalarTruncateAddUInt(simpleInterestFactor, borrowIndexPrior, borrowIndexPrior);
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            /* We write the previously calculated values into storage */
            accrualBlockNumber = currentBlockNumber;
            borrowIndex = borrowIndexNew;
            totalBorrows = totalBorrowsNew;
            totalReserves = totalReservesNew;
    
            /* We emit an AccrueInterest event */
            emit AccrueInterest(cashPrior, interestAccumulated, borrowIndexNew, totalBorrowsNew);
    
            return NO_ERROR;
        }
    
        /**
         * @notice Sender supplies assets into the market and receives cTokens in exchange
         * @dev Accrues interest whether or not the operation succeeds, unless reverted
         * @param mintAmount The amount of the underlying asset to supply
         */
        function mintInternal(uint mintAmount) internal nonReentrant {
            accrueInterest();
            // mintFresh emits the actual Mint event if successful and logs on errors, so we don't need to
            mintFresh(msg.sender, mintAmount);
        }
    
        /**
         * @notice User supplies assets into the market and receives cTokens in exchange
         * @dev Assumes interest has already been accrued up to the current block
         * @param minter The address of the account which is supplying the assets
         * @param mintAmount The amount of the underlying asset to supply
         */
        function mintFresh(address minter, uint mintAmount) internal {
            /* Fail if mint not allowed */
            uint allowed = comptroller.mintAllowed(address(this), minter, mintAmount);
            if (allowed != 0) {
                revert MintComptrollerRejection(allowed);
            }
    
            /* Verify market's block number equals current block number */
            if (accrualBlockNumber != getBlockNumber()) {
                revert MintFreshnessCheck();
            }
    
            Exp memory exchangeRate = Exp({mantissa: exchangeRateStoredInternal()});
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            /*
             *  We call `doTransferIn` for the minter and the mintAmount.
             *  Note: The cToken must handle variations between ERC-20 and ETH underlying.
             *  `doTransferIn` reverts if anything goes wrong, since we can't be sure if
             *  side-effects occurred. The function returns the amount actually transferred,
             *  in case of a fee. On success, the cToken holds an additional `actualMintAmount`
             *  of cash.
             */
            uint actualMintAmount = doTransferIn(minter, mintAmount);
    
            /*
             * We get the current exchange rate and calculate the number of cTokens to be minted:
             *  mintTokens = actualMintAmount / exchangeRate
             */
    
            uint mintTokens = div_(actualMintAmount, exchangeRate);
    
            /*
             * We calculate the new total supply of cTokens and minter token balance, checking for overflow:
             *  totalSupplyNew = totalSupply + mintTokens
             *  accountTokensNew = accountTokens[minter] + mintTokens
             * And write them into storage
             */
            totalSupply = totalSupply + mintTokens;
            accountTokens[minter] = accountTokens[minter] + mintTokens;
    
            /* We emit a Mint event, and a Transfer event */
            emit Mint(minter, actualMintAmount, mintTokens);
            emit Transfer(address(this), minter, mintTokens);
    
            /* We call the defense hook */
            // unused function
            // comptroller.mintVerify(address(this), minter, actualMintAmount, mintTokens);
        }
    
        /**
         * @notice Sender redeems cTokens in exchange for the underlying asset
         * @dev Accrues interest whether or not the operation succeeds, unless reverted
         * @param redeemTokens The number of cTokens to redeem into underlying
         */
        function redeemInternal(uint redeemTokens) internal nonReentrant {
            accrueInterest();
            // redeemFresh emits redeem-specific logs on errors, so we don't need to
            redeemFresh(payable(msg.sender), redeemTokens, 0);
        }
    
        /**
         * @notice Sender redeems cTokens in exchange for a specified amount of underlying asset
         * @dev Accrues interest whether or not the operation succeeds, unless reverted
         * @param redeemAmount The amount of underlying to receive from redeeming cTokens
         */
        function redeemUnderlyingInternal(uint redeemAmount) internal nonReentrant {
            accrueInterest();
            // redeemFresh emits redeem-specific logs on errors, so we don't need to
            redeemFresh(payable(msg.sender), 0, redeemAmount);
        }
    
        /**
         * @notice User redeems cTokens in exchange for the underlying asset
         * @dev Assumes interest has already been accrued up to the current block
         * @param redeemer The address of the account which is redeeming the tokens
         * @param redeemTokensIn The number of cTokens to redeem into underlying (only one of redeemTokensIn or redeemAmountIn may be non-zero)
         * @param redeemAmountIn The number of underlying tokens to receive from redeeming cTokens (only one of redeemTokensIn or redeemAmountIn may be non-zero)
         */
        function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal {
            require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero");
    
            /* exchangeRate = invoke Exchange Rate Stored() */
            Exp memory exchangeRate = Exp({mantissa: exchangeRateStoredInternal() });
    
            uint redeemTokens;
            uint redeemAmount;
            /* If redeemTokensIn > 0: */
            if (redeemTokensIn > 0) {
                /*
                 * We calculate the exchange rate and the amount of underlying to be redeemed:
                 *  redeemTokens = redeemTokensIn
                 *  redeemAmount = redeemTokensIn x exchangeRateCurrent
                 */
                redeemTokens = redeemTokensIn;
                redeemAmount = mul_ScalarTruncate(exchangeRate, redeemTokensIn);
            } else {
                /*
                 * We get the current exchange rate and calculate the amount to be redeemed:
                 *  redeemTokens = redeemAmountIn / exchangeRate
                 *  redeemAmount = redeemAmountIn
                 */
                redeemTokens = div_(redeemAmountIn, exchangeRate);
                redeemAmount = redeemAmountIn;
            }
    
            /* Fail if redeem not allowed */
            uint allowed = comptroller.redeemAllowed(address(this), redeemer, redeemTokens);
            if (allowed != 0) {
                revert RedeemComptrollerRejection(allowed);
            }
    
            /* Verify market's block number equals current block number */
            if (accrualBlockNumber != getBlockNumber()) {
                revert RedeemFreshnessCheck();
            }
    
            /* Fail gracefully if protocol has insufficient cash */
            if (getCashPrior() < redeemAmount) {
                revert RedeemTransferOutNotPossible();
            }
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
    
            /*
             * We write the previously calculated values into storage.
             *  Note: Avoid token reentrancy attacks by writing reduced supply before external transfer.
             */
            totalSupply = totalSupply - redeemTokens;
            accountTokens[redeemer] = accountTokens[redeemer] - redeemTokens;
    
            /*
             * We invoke doTransferOut for the redeemer and the redeemAmount.
             *  Note: The cToken must handle variations between ERC-20 and ETH underlying.
             *  On success, the cToken has redeemAmount less of cash.
             *  doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.
             */
            doTransferOut(redeemer, redeemAmount);
    
            /* We emit a Transfer event, and a Redeem event */
            emit Transfer(redeemer, address(this), redeemTokens);
            emit Redeem(redeemer, redeemAmount, redeemTokens);
    
            /* We call the defense hook */
            comptroller.redeemVerify(address(this), redeemer, redeemAmount, redeemTokens);
        }
    
        /**
          * @notice Sender borrows assets from the protocol to their own address
          * @param borrowAmount The amount of the underlying asset to borrow
          */
        function borrowInternal(uint borrowAmount) internal nonReentrant {
            accrueInterest();
            // borrowFresh emits borrow-specific logs on errors, so we don't need to
            borrowFresh(payable(msg.sender), borrowAmount);
        }
    
        /**
          * @notice Users borrow assets from the protocol to their own address
          * @param borrowAmount The amount of the underlying asset to borrow
          */
        function borrowFresh(address payable borrower, uint borrowAmount) internal {
            /* Fail if borrow not allowed */
            uint allowed = comptroller.borrowAllowed(address(this), borrower, borrowAmount);
            if (allowed != 0) {
                revert BorrowComptrollerRejection(allowed);
            }
    
            /* Verify market's block number equals current block number */
            if (accrualBlockNumber != getBlockNumber()) {
                revert BorrowFreshnessCheck();
            }
    
            /* Fail gracefully if protocol has insufficient underlying cash */
            if (getCashPrior() < borrowAmount) {
                revert BorrowCashNotAvailable();
            }
    
            /*
             * We calculate the new borrower and total borrow balances, failing on overflow:
             *  accountBorrowNew = accountBorrow + borrowAmount
             *  totalBorrowsNew = totalBorrows + borrowAmount
             */
            uint accountBorrowsPrev = borrowBalanceStoredInternal(borrower);
            uint accountBorrowsNew = accountBorrowsPrev + borrowAmount;
            uint totalBorrowsNew = totalBorrows + borrowAmount;
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            /*
             * We write the previously calculated values into storage.
             *  Note: Avoid token reentrancy attacks by writing increased borrow before external transfer.
            `*/
            accountBorrows[borrower].principal = accountBorrowsNew;
            accountBorrows[borrower].interestIndex = borrowIndex;
            totalBorrows = totalBorrowsNew;
    
            /*
             * We invoke doTransferOut for the borrower and the borrowAmount.
             *  Note: The cToken must handle variations between ERC-20 and ETH underlying.
             *  On success, the cToken borrowAmount less of cash.
             *  doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.
             */
            doTransferOut(borrower, borrowAmount);
    
            /* We emit a Borrow event */
            emit Borrow(borrower, borrowAmount, accountBorrowsNew, totalBorrowsNew);
        }
    
        /**
         * @notice Sender repays their own borrow
         * @param repayAmount The amount to repay, or -1 for the full outstanding amount
         */
        function repayBorrowInternal(uint repayAmount) internal nonReentrant {
            accrueInterest();
            // repayBorrowFresh emits repay-borrow-specific logs on errors, so we don't need to
            repayBorrowFresh(msg.sender, msg.sender, repayAmount);
        }
    
        /**
         * @notice Sender repays a borrow belonging to borrower
         * @param borrower the account with the debt being payed off
         * @param repayAmount The amount to repay, or -1 for the full outstanding amount
         */
        function repayBorrowBehalfInternal(address borrower, uint repayAmount) internal nonReentrant {
            accrueInterest();
            // repayBorrowFresh emits repay-borrow-specific logs on errors, so we don't need to
            repayBorrowFresh(msg.sender, borrower, repayAmount);
        }
    
        /**
         * @notice Borrows are repaid by another user (possibly the borrower).
         * @param payer the account paying off the borrow
         * @param borrower the account with the debt being payed off
         * @param repayAmount the amount of underlying tokens being returned, or -1 for the full outstanding amount
         * @return (uint) the actual repayment amount.
         */
        function repayBorrowFresh(address payer, address borrower, uint repayAmount) internal returns (uint) {
            /* Fail if repayBorrow not allowed */
            uint allowed = comptroller.repayBorrowAllowed(address(this), payer, borrower, repayAmount);
            if (allowed != 0) {
                revert RepayBorrowComptrollerRejection(allowed);
            }
    
            /* Verify market's block number equals current block number */
            if (accrualBlockNumber != getBlockNumber()) {
                revert RepayBorrowFreshnessCheck();
            }
    
            /* We fetch the amount the borrower owes, with accumulated interest */
            uint accountBorrowsPrev = borrowBalanceStoredInternal(borrower);
    
            /* If repayAmount == -1, repayAmount = accountBorrows */
            uint repayAmountFinal = repayAmount == type(uint).max ? accountBorrowsPrev : repayAmount;
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            /*
             * We call doTransferIn for the payer and the repayAmount
             *  Note: The cToken must handle variations between ERC-20 and ETH underlying.
             *  On success, the cToken holds an additional repayAmount of cash.
             *  doTransferIn reverts if anything goes wrong, since we can't be sure if side effects occurred.
             *   it returns the amount actually transferred, in case of a fee.
             */
            uint actualRepayAmount = doTransferIn(payer, repayAmountFinal);
    
            /*
             * We calculate the new borrower and total borrow balances, failing on underflow:
             *  accountBorrowsNew = accountBorrows - actualRepayAmount
             *  totalBorrowsNew = totalBorrows - actualRepayAmount
             */
            uint accountBorrowsNew = accountBorrowsPrev - actualRepayAmount;
            uint totalBorrowsNew = totalBorrows - actualRepayAmount;
    
            /* We write the previously calculated values into storage */
            accountBorrows[borrower].principal = accountBorrowsNew;
            accountBorrows[borrower].interestIndex = borrowIndex;
            totalBorrows = totalBorrowsNew;
    
            /* We emit a RepayBorrow event */
            emit RepayBorrow(payer, borrower, actualRepayAmount, accountBorrowsNew, totalBorrowsNew);
    
            return actualRepayAmount;
        }
    
        /**
         * @notice The sender liquidates the borrowers collateral.
         *  The collateral seized is transferred to the liquidator.
         * @param borrower The borrower of this cToken to be liquidated
         * @param cTokenCollateral The market in which to seize collateral from the borrower
         * @param repayAmount The amount of the underlying borrowed asset to repay
         */
        function liquidateBorrowInternal(address borrower, uint repayAmount, CTokenInterface cTokenCollateral) internal nonReentrant {
            accrueInterest();
    
            uint error = cTokenCollateral.accrueInterest();
            if (error != NO_ERROR) {
                // accrueInterest emits logs on errors, but we still want to log the fact that an attempted liquidation failed
                revert LiquidateAccrueCollateralInterestFailed(error);
            }
    
            // liquidateBorrowFresh emits borrow-specific logs on errors, so we don't need to
            liquidateBorrowFresh(msg.sender, borrower, repayAmount, cTokenCollateral);
        }
    
        /**
         * @notice The liquidator liquidates the borrowers collateral.
         *  The collateral seized is transferred to the liquidator.
         * @param borrower The borrower of this cToken to be liquidated
         * @param liquidator The address repaying the borrow and seizing collateral
         * @param cTokenCollateral The market in which to seize collateral from the borrower
         * @param repayAmount The amount of the underlying borrowed asset to repay
         */
        function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, CTokenInterface cTokenCollateral) internal {
            /* Fail if liquidate not allowed */
            uint allowed = comptroller.liquidateBorrowAllowed(address(this), address(cTokenCollateral), liquidator, borrower, repayAmount);
            if (allowed != 0) {
                revert LiquidateComptrollerRejection(allowed);
            }
    
            /* Verify market's block number equals current block number */
            if (accrualBlockNumber != getBlockNumber()) {
                revert LiquidateFreshnessCheck();
            }
    
            /* Verify cTokenCollateral market's block number equals current block number */
            if (cTokenCollateral.accrualBlockNumber() != getBlockNumber()) {
                revert LiquidateCollateralFreshnessCheck();
            }
    
            /* Fail if borrower = liquidator */
            if (borrower == liquidator) {
                revert LiquidateLiquidatorIsBorrower();
            }
    
            /* Fail if repayAmount = 0 */
            if (repayAmount == 0) {
                revert LiquidateCloseAmountIsZero();
            }
    
            /* Fail if repayAmount = -1 */
            if (repayAmount == type(uint).max) {
                revert LiquidateCloseAmountIsUintMax();
            }
    
            /* Fail if repayBorrow fails */
            uint actualRepayAmount = repayBorrowFresh(liquidator, borrower, repayAmount);
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            /* We calculate the number of collateral tokens that will be seized */
            (uint amountSeizeError, uint seizeTokens) = comptroller.liquidateCalculateSeizeTokens(address(this), address(cTokenCollateral), actualRepayAmount);
            require(amountSeizeError == NO_ERROR, "LIQUIDATE_COMPTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED");
    
            /* Revert if borrower collateral token balance < seizeTokens */
            require(cTokenCollateral.balanceOf(borrower) >= seizeTokens, "LIQUIDATE_SEIZE_TOO_MUCH");
    
            // If this is also the collateral, run seizeInternal to avoid re-entrancy, otherwise make an external call
            if (address(cTokenCollateral) == address(this)) {
                seizeInternal(address(this), liquidator, borrower, seizeTokens);
            } else {
                require(cTokenCollateral.seize(liquidator, borrower, seizeTokens) == NO_ERROR, "token seizure failed");
            }
    
            /* We emit a LiquidateBorrow event */
            emit LiquidateBorrow(liquidator, borrower, actualRepayAmount, address(cTokenCollateral), seizeTokens);
        }
    
        /**
         * @notice Transfers collateral tokens (this market) to the liquidator.
         * @dev Will fail unless called by another cToken during the process of liquidation.
         *  Its absolutely critical to use msg.sender as the borrowed cToken and not a parameter.
         * @param liquidator The account receiving seized collateral
         * @param borrower The account having collateral seized
         * @param seizeTokens The number of cTokens to seize
         * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
         */
        function seize(address liquidator, address borrower, uint seizeTokens) override external nonReentrant returns (uint) {
            seizeInternal(msg.sender, liquidator, borrower, seizeTokens);
    
            return NO_ERROR;
        }
    
        /**
         * @notice Transfers collateral tokens (this market) to the liquidator.
         * @dev Called only during an in-kind liquidation, or by liquidateBorrow during the liquidation of another CToken.
         *  Its absolutely critical to use msg.sender as the seizer cToken and not a parameter.
         * @param seizerToken The contract seizing the collateral (i.e. borrowed cToken)
         * @param liquidator The account receiving seized collateral
         * @param borrower The account having collateral seized
         * @param seizeTokens The number of cTokens to seize
         */
        function seizeInternal(address seizerToken, address liquidator, address borrower, uint seizeTokens) internal {
            /* Fail if seize not allowed */
            uint allowed = comptroller.seizeAllowed(address(this), seizerToken, liquidator, borrower, seizeTokens);
            if (allowed != 0) {
                revert LiquidateSeizeComptrollerRejection(allowed);
            }
    
            /* Fail if borrower = liquidator */
            if (borrower == liquidator) {
                revert LiquidateSeizeLiquidatorIsBorrower();
            }
    
            /*
             * We calculate the new borrower and liquidator token balances, failing on underflow/overflow:
             *  borrowerTokensNew = accountTokens[borrower] - seizeTokens
             *  liquidatorTokensNew = accountTokens[liquidator] + seizeTokens
             */
            uint protocolSeizeTokens = mul_(seizeTokens, Exp({mantissa: protocolSeizeShareMantissa}));
            uint liquidatorSeizeTokens = seizeTokens - protocolSeizeTokens;
            Exp memory exchangeRate = Exp({mantissa: exchangeRateStoredInternal()});
            uint protocolSeizeAmount = mul_ScalarTruncate(exchangeRate, protocolSeizeTokens);
            uint totalReservesNew = totalReserves + protocolSeizeAmount;
    
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            /* We write the calculated values into storage */
            totalReserves = totalReservesNew;
            totalSupply = totalSupply - protocolSeizeTokens;
            accountTokens[borrower] = accountTokens[borrower] - seizeTokens;
            accountTokens[liquidator] = accountTokens[liquidator] + liquidatorSeizeTokens;
    
            /* Emit a Transfer event */
            emit Transfer(borrower, liquidator, liquidatorSeizeTokens);
            emit Transfer(borrower, address(this), protocolSeizeTokens);
            emit ReservesAdded(address(this), protocolSeizeAmount, totalReservesNew);
        }
    
    
        /*** Admin Functions ***/
    
        /**
          * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.
          * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.
          * @param newPendingAdmin New pending admin.
          * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
          */
        function _setPendingAdmin(address payable newPendingAdmin) override external returns (uint) {
            // Check caller = admin
            if (msg.sender != admin) {
                revert SetPendingAdminOwnerCheck();
            }
    
            // Save current value, if any, for inclusion in log
            address oldPendingAdmin = pendingAdmin;
    
            // Store pendingAdmin with value newPendingAdmin
            pendingAdmin = newPendingAdmin;
    
            // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin)
            emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin);
    
            return NO_ERROR;
        }
    
        /**
          * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin
          * @dev Admin function for pending admin to accept role and update admin
          * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
          */
        function _acceptAdmin() override external returns (uint) {
            // Check caller is pendingAdmin and pendingAdmin ≠ address(0)
            if (msg.sender != pendingAdmin || msg.sender == address(0)) {
                revert AcceptAdminPendingAdminCheck();
            }
    
            // Save current values for inclusion in log
            address oldAdmin = admin;
            address oldPendingAdmin = pendingAdmin;
    
            // Store admin with value pendingAdmin
            admin = pendingAdmin;
    
            // Clear the pending value
            pendingAdmin = payable(address(0));
    
            emit NewAdmin(oldAdmin, admin);
            emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);
    
            return NO_ERROR;
        }
    
        /**
          * @notice Sets a new comptroller for the market
          * @dev Admin function to set a new comptroller
          * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
          */
        function _setComptroller(ComptrollerInterface newComptroller) override public returns (uint) {
            // Check caller is admin
            if (msg.sender != admin) {
                revert SetComptrollerOwnerCheck();
            }
    
            ComptrollerInterface oldComptroller = comptroller;
            // Ensure invoke comptroller.isComptroller() returns true
            require(newComptroller.isComptroller(), "marker method returned false");
    
            // Set market's comptroller to newComptroller
            comptroller = newComptroller;
    
            // Emit NewComptroller(oldComptroller, newComptroller)
            emit NewComptroller(oldComptroller, newComptroller);
    
            return NO_ERROR;
        }
    
        /**
          * @notice accrues interest and sets a new reserve factor for the protocol using _setReserveFactorFresh
          * @dev Admin function to accrue interest and set a new reserve factor
          * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
          */
        function _setReserveFactor(uint newReserveFactorMantissa) override external nonReentrant returns (uint) {
            accrueInterest();
            // _setReserveFactorFresh emits reserve-factor-specific logs on errors, so we don't need to.
            return _setReserveFactorFresh(newReserveFactorMantissa);
        }
    
        /**
          * @notice Sets a new reserve factor for the protocol (*requires fresh interest accrual)
          * @dev Admin function to set a new reserve factor
          * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
          */
        function _setReserveFactorFresh(uint newReserveFactorMantissa) internal returns (uint) {
            // Check caller is admin
            if (msg.sender != admin) {
                revert SetReserveFactorAdminCheck();
            }
    
            // Verify market's block number equals current block number
            if (accrualBlockNumber != getBlockNumber()) {
                revert SetReserveFactorFreshCheck();
            }
    
            // Check newReserveFactor ≤ maxReserveFactor
            if (newReserveFactorMantissa > reserveFactorMaxMantissa) {
                revert SetReserveFactorBoundsCheck();
            }
    
            uint oldReserveFactorMantissa = reserveFactorMantissa;
            reserveFactorMantissa = newReserveFactorMantissa;
    
            emit NewReserveFactor(oldReserveFactorMantissa, newReserveFactorMantissa);
    
            return NO_ERROR;
        }
    
        /**
         * @notice Accrues interest and reduces reserves by transferring from msg.sender
         * @param addAmount Amount of addition to reserves
         * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
         */
        function _addReservesInternal(uint addAmount) internal nonReentrant returns (uint) {
            accrueInterest();
    
            // _addReservesFresh emits reserve-addition-specific logs on errors, so we don't need to.
            _addReservesFresh(addAmount);
            return NO_ERROR;
        }
    
        /**
         * @notice Add reserves by transferring from caller
         * @dev Requires fresh interest accrual
         * @param addAmount Amount of addition to reserves
         * @return (uint, uint) An error code (0=success, otherwise a failure (see ErrorReporter.sol for details)) and the actual amount added, net token fees
         */
        function _addReservesFresh(uint addAmount) internal returns (uint, uint) {
            // totalReserves + actualAddAmount
            uint totalReservesNew;
            uint actualAddAmount;
    
            // We fail gracefully unless market's block number equals current block number
            if (accrualBlockNumber != getBlockNumber()) {
                revert AddReservesFactorFreshCheck(actualAddAmount);
            }
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            /*
             * We call doTransferIn for the caller and the addAmount
             *  Note: The cToken must handle variations between ERC-20 and ETH underlying.
             *  On success, the cToken holds an additional addAmount of cash.
             *  doTransferIn reverts if anything goes wrong, since we can't be sure if side effects occurred.
             *  it returns the amount actually transferred, in case of a fee.
             */
    
            actualAddAmount = doTransferIn(msg.sender, addAmount);
    
            totalReservesNew = totalReserves + actualAddAmount;
    
            // Store reserves[n+1] = reserves[n] + actualAddAmount
            totalReserves = totalReservesNew;
    
            /* Emit NewReserves(admin, actualAddAmount, reserves[n+1]) */
            emit ReservesAdded(msg.sender, actualAddAmount, totalReservesNew);
    
            /* Return (NO_ERROR, actualAddAmount) */
            return (NO_ERROR, actualAddAmount);
        }
    
    
        /**
         * @notice Accrues interest and reduces reserves by transferring to admin
         * @param reduceAmount Amount of reduction to reserves
         * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
         */
        function _reduceReserves(uint reduceAmount) override external nonReentrant returns (uint) {
            accrueInterest();
            // _reduceReservesFresh emits reserve-reduction-specific logs on errors, so we don't need to.
            return _reduceReservesFresh(reduceAmount);
        }
    
        /**
         * @notice Reduces reserves by transferring to admin
         * @dev Requires fresh interest accrual
         * @param reduceAmount Amount of reduction to reserves
         * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
         */
        function _reduceReservesFresh(uint reduceAmount) internal returns (uint) {
            // totalReserves - reduceAmount
            uint totalReservesNew;
    
            // Check caller is admin
            if (msg.sender != admin) {
                revert ReduceReservesAdminCheck();
            }
    
            // We fail gracefully unless market's block number equals current block number
            if (accrualBlockNumber != getBlockNumber()) {
                revert ReduceReservesFreshCheck();
            }
    
            // Fail gracefully if protocol has insufficient underlying cash
            if (getCashPrior() < reduceAmount) {
                revert ReduceReservesCashNotAvailable();
            }
    
            // Check reduceAmount ≤ reserves[n] (totalReserves)
            if (reduceAmount > totalReserves) {
                revert ReduceReservesCashValidation();
            }
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            totalReservesNew = totalReserves - reduceAmount;
    
            // Store reserves[n+1] = reserves[n] - reduceAmount
            totalReserves = totalReservesNew;
    
            // doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.
            doTransferOut(admin, reduceAmount);
    
            emit ReservesReduced(admin, reduceAmount, totalReservesNew);
    
            return NO_ERROR;
        }
    
        /**
         * @notice accrues interest and updates the interest rate model using _setInterestRateModelFresh
         * @dev Admin function to accrue interest and update the interest rate model
         * @param newInterestRateModel the new interest rate model to use
         * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
         */
        function _setInterestRateModel(InterestRateModel newInterestRateModel) override public returns (uint) {
            accrueInterest();
            // _setInterestRateModelFresh emits interest-rate-model-update-specific logs on errors, so we don't need to.
            return _setInterestRateModelFresh(newInterestRateModel);
        }
    
        /**
         * @notice updates the interest rate model (*requires fresh interest accrual)
         * @dev Admin function to update the interest rate model
         * @param newInterestRateModel the new interest rate model to use
         * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
         */
        function _setInterestRateModelFresh(InterestRateModel newInterestRateModel) internal returns (uint) {
    
            // Used to store old model for use in the event that is emitted on success
            InterestRateModel oldInterestRateModel;
    
            // Check caller is admin
            if (msg.sender != admin) {
                revert SetInterestRateModelOwnerCheck();
            }
    
            // We fail gracefully unless market's block number equals current block number
            if (accrualBlockNumber != getBlockNumber()) {
                revert SetInterestRateModelFreshCheck();
            }
    
            // Track the market's current interest rate model
            oldInterestRateModel = interestRateModel;
    
            // Ensure invoke newInterestRateModel.isInterestRateModel() returns true
            require(newInterestRateModel.isInterestRateModel(), "marker method returned false");
    
            // Set the interest rate model to newInterestRateModel
            interestRateModel = newInterestRateModel;
    
            // Emit NewMarketInterestRateModel(oldInterestRateModel, newInterestRateModel)
            emit NewMarketInterestRateModel(oldInterestRateModel, newInterestRateModel);
    
            return NO_ERROR;
        }
    
        /*** Safe Token ***/
    
        /**
         * @notice Gets balance of this contract in terms of the underlying
         * @dev This excludes the value of the current message, if any
         * @return The quantity of underlying owned by this contract
         */
        function getCashPrior() virtual internal view returns (uint);
    
        /**
         * @dev Performs a transfer in, reverting upon failure. Returns the amount actually transferred to the protocol, in case of a fee.
         *  This may revert due to insufficient balance or insufficient allowance.
         */
        function doTransferIn(address from, uint amount) virtual internal returns (uint);
    
        /**
         * @dev Performs a transfer out, ideally returning an explanatory error code upon failure rather than reverting.
         *  If caller has not called checked protocol's balance, may revert due to insufficient cash held in the contract.
         *  If caller has checked protocol's balance, and verified it is >= amount, this should not revert in normal conditions.
         */
        function doTransferOut(address payable to, uint amount) virtual internal;
    
    
        /*** Reentrancy Guard ***/
    
        /**
         * @dev Prevents a contract from calling itself, directly or indirectly.
         */
        modifier nonReentrant() {
            require(_notEntered, "re-entered");
            _notEntered = false;
            _;
            _notEntered = true; // get a gas-refund post-Istanbul
        }
    }
    

#### mint函数

存款，之所以叫 mint，是因为该操作会新增 cToken 数量，即 totalSupply 增加了，就等于挖矿了 cToken。该操作会将用户的标的资产转入 cToken 合约中（数据会存储在代理合约中），并根据最新的兑换率将对应的 cToken 代币转到用户钱包地址。

mint函数在compound中的实现很复杂，添加了很多的检查，但其实质逻辑很简单，如下：

    //老版本逻辑 新版基本差不多
    
    function mint(uint mintAmount) external returns (uint) {
            //检查1. 应付未付利息
        require(accrueInterest()==uint(Error.NO_ERROR));
        //检查2：审计合约是否允许该合约铸币
        require(mintAllowed(address(this), minter, mintAmount)==uint(Error.NO_ERROR));
        //检查3：检查market的区块编号是否为当前编号
        require(block.number==accureBlockNumber);
        //检查4：检查msg.sender是否有足够的token余额来transfer给minter合约
        require(checkTransferIn(minter, mintAmount));
            //计算1：计算当前的cToken兑换Token的汇率
        (,vars.exchangeRateMantissa)= exchangeRateStoredInternal();
        //存币到minter合约
        token.transferFrom(msg.sender, address(this), mintAmount);
            //计算2：根据汇率算出需要铸造的cToken的数量
        vars.mintToken = mintAmount / vars.exchangeRateMantissa;
        //生效1：更新全局变量totalSupply
        totalSupply = totalSupply + vars.mintToken;
        //生效2：更新全局变量accountTokens[minter],当前用户的余额
        accountTokens[minter] = accountTokens[minter] + vars.mintToken;
        //检查5：调用审计合约检查是否铸币成功
        comptroller.mintVerify(address(this),minter,vars.actualMintAmount,vars.mintTokens);
        //返回：铸造的cToken数量
        return vars.mintToken;
        
    }
    

![img](https://storage.googleapis.com/papyrus_images/d74f71eb49f7e2aa808feee81457937a071416fc1c5ac5b6af85af8c6f277aee.png)

img

    //cErc20.sol 中mint方法
        /**
         * @notice Sender supplies assets into the market and receives cTokens in exchange
         * @dev Accrues interest whether or not the operation succeeds, unless reverted
         * @param mintAmount The amount of the underlying asset to supply
         * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
         */
        function mint(uint mintAmount) override external returns (uint) {
          //调用cToken.sol中的mintInternal方法  
          mintInternal(mintAmount);
            return NO_ERROR;
        }
    
    
    
    //cToken.sol中mintInternal方法
            /**
         * @notice Sender supplies assets into the market and receives cTokens in exchange
         * @dev Accrues interest whether or not the operation succeeds, unless reverted
         * @param mintAmount The amount of the underlying asset to supply
         */
        function mintInternal(uint mintAmount) internal nonReentrant {
            //检查应付未付利息是否为0
              accrueInterest();
            // mintFresh emits the actual Mint event if successful and logs on errors, so we don't need to
               //调用mintFresh方法
              mintFresh(msg.sender, mintAmount);
        }
    
    
    
    //cToken.sol中mintFresh方法
    //用户向市场提供资产，并获得cTokens作为交换。
        /**
         * @notice User supplies assets into the market and receives cTokens in exchange
         * @dev Assumes interest has already been accrued up to the current block
         * @param minter The address of the account which is supplying the assets
         * @param mintAmount The amount of the underlying asset to supply
         */
        function mintFresh(address minter, uint mintAmount) internal {
            /* Fail if mint not allowed */
              //检查审计合约是否允许铸币
            uint allowed = comptroller.mintAllowed(address(this), minter, mintAmount);
            if (allowed != 0) {
                revert MintComptrollerRejection(allowed);
            }
    
            /* Verify market's block number equals current block number */
              //验证market的区块号码是否等于当前区块号码
            if (accrualBlockNumber != getBlockNumber()) {
                revert MintFreshnessCheck();
            }
                    //获取兑换率
            Exp memory exchangeRate = Exp({mantissa: exchangeRateStoredInternal()});
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            /*
             *  We call `doTransferIn` for the minter and the mintAmount.
             *  Note: The cToken must handle variations between ERC-20 and ETH underlying.
             *  `doTransferIn` reverts if anything goes wrong, since we can't be sure if
             *  side-effects occurred. The function returns the amount actually transferred,
             *  in case of a fee. On success, the cToken holds an additional `actualMintAmount`
             *  of cash.
             */
            uint actualMintAmount = doTransferIn(minter, mintAmount);
    
            /*
             * We get the current exchange rate and calculate the number of cTokens to be minted:
             *  mintTokens = actualMintAmount / exchangeRate
             */
    
            uint mintTokens = div_(actualMintAmount, exchangeRate);
    
            /*
             * We calculate the new total supply of cTokens and minter token balance, checking for overflow:
             *  totalSupplyNew = totalSupply + mintTokens
             *  accountTokensNew = accountTokens[minter] + mintTokens
             * And write them into storage
             */
            totalSupply = totalSupply + mintTokens;
            accountTokens[minter] = accountTokens[minter] + mintTokens;
    
            /* We emit a Mint event, and a Transfer event */
            emit Mint(minter, actualMintAmount, mintTokens);
            emit Transfer(address(this), minter, mintTokens);
    
            /* We call the defense hook */
            // unused function
            // comptroller.mintVerify(address(this), minter, actualMintAmount, mintTokens);
        }
    

#### redeem函数

赎回存款，即用 cToken 换回标的资产，会根据最新的兑换率计算能换回多少标的资产。

    //cErc20.sol 中的redeem方法
             /**
         * @notice Sender redeems cTokens in exchange for the underlying asset
         * @dev Accrues interest whether or not the operation succeeds, unless reverted
         * @param redeemTokens The number of cTokens to redeem into underlying
         * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
         */
        function redeem(uint redeemTokens) override external returns (uint) {
            redeemInternal(redeemTokens);
            return NO_ERROR;
        }
    
    
    //cToken.sol 中的redeemInternal方法
        /**
         * @notice Sender redeems cTokens in exchange for the underlying asset
         * @dev Accrues interest whether or not the operation succeeds, unless reverted
         * @param redeemTokens The number of cTokens to redeem into underlying
         */
        function redeemInternal(uint redeemTokens) internal nonReentrant {
            
              accrueInterest();
            // redeemFresh emits redeem-specific logs on errors, so we don't need to
            redeemFresh(payable(msg.sender), redeemTokens, 0);
        }
    
    
    //cToken.sol 中的redeemFresh方法
             /**
         * @notice User redeems cTokens in exchange for the underlying asset
         * @dev Assumes interest has already been accrued up to the current block
         * @param redeemer The address of the account which is redeeming the tokens
         * @param redeemTokensIn The number of cTokens to redeem into underlying (only one of redeemTokensIn or redeemAmountIn may be non-zero)
         * @param redeemAmountIn The number of underlying tokens to receive from redeeming cTokens (only one of redeemTokensIn or redeemAmountIn may be non-zero)
         */
            //可以传入标的资产或者对应的CToken
        function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal {
            require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero");
    
            /* exchangeRate = invoke Exchange Rate Stored() */
            Exp memory exchangeRate = Exp({mantissa: exchangeRateStoredInternal() });
    
            uint redeemTokens;
            uint redeemAmount;
            /* If redeemTokensIn > 0: */
            if (redeemTokensIn > 0) {
                /*
                 * We calculate the exchange rate and the amount of underlying to be redeemed:
                 *  redeemTokens = redeemTokensIn
                 *  redeemAmount = redeemTokensIn x exchangeRateCurrent
                 */
                redeemTokens = redeemTokensIn;
                redeemAmount = mul_ScalarTruncate(exchangeRate, redeemTokensIn);
            } else {
                /*
                 * We get the current exchange rate and calculate the amount to be redeemed:
                 *  redeemTokens = redeemAmountIn / exchangeRate
                 *  redeemAmount = redeemAmountIn
                 */
                redeemTokens = div_(redeemAmountIn, exchangeRate);
                redeemAmount = redeemAmountIn;
            }
    
            /* Fail if redeem not allowed */
            uint allowed = comptroller.redeemAllowed(address(this), redeemer, redeemTokens);
            if (allowed != 0) {
                revert RedeemComptrollerRejection(allowed);
            }
    
            /* Verify market's block number equals current block number */
            if (accrualBlockNumber != getBlockNumber()) {
                revert RedeemFreshnessCheck();
            }
    
            /* Fail gracefully if protocol has insufficient cash */
            if (getCashPrior() < redeemAmount) {
                revert RedeemTransferOutNotPossible();
            }
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
    
            /*
             * We write the previously calculated values into storage.
             *  Note: Avoid token reentrancy attacks by writing reduced supply before external transfer.
             */
            totalSupply = totalSupply - redeemTokens;
            accountTokens[redeemer] = accountTokens[redeemer] - redeemTokens;
    
            /*
             * We invoke doTransferOut for the redeemer and the redeemAmount.
             *  Note: The cToken must handle variations between ERC-20 and ETH underlying.
             *  On success, the cToken has redeemAmount less of cash.
             *  doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.
             */
            doTransferOut(redeemer, redeemAmount);
    
            /* We emit a Transfer event, and a Redeem event */
            emit Transfer(redeemer, address(this), redeemTokens);
            emit Redeem(redeemer, redeemAmount, redeemTokens);
    
            /* We call the defense hook */
            comptroller.redeemVerify(address(this), redeemer, redeemAmount, redeemTokens);
        }
    

![img](https://storage.googleapis.com/papyrus_images/9d324ff5b54b205034eb745ee2c405be6cb4cb0f07620552b33843ff1a441520.png)

img

#### borrow函数

借款，会根据用户的抵押物来计算可借额度，借款成功则将所借资产从资金池中直接转到用户钱包地址。

token->borrower

    //cErc20.sol borrow
        /**
          * @notice Sender borrows assets from the protocol to their own address
          * @param borrowAmount The amount of the underlying asset to borrow
          * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
          */
        function borrow(uint borrowAmount) override external returns (uint) {
            borrowInternal(borrowAmount);
            return NO_ERROR;
        }
    
    
    //cToken.sol borrowInternal
            /**
          * @notice Sender borrows assets from the protocol to their own address
          * @param borrowAmount The amount of the underlying asset to borrow
          */
        function borrowInternal(uint borrowAmount) internal nonReentrant {
            accrueInterest();
            // borrowFresh emits borrow-specific logs on errors, so we don't need to
            borrowFresh(payable(msg.sender), borrowAmount);
        }
    
    
    
    //cToken.sol borrowFresh
                 /**
          * @notice Users borrow assets from the protocol to their own address
          * @param borrowAmount The amount of the underlying asset to borrow
          */
        function borrowFresh(address payable borrower, uint borrowAmount) internal {
            /* Fail if borrow not allowed */
            uint allowed = comptroller.borrowAllowed(address(this), borrower, borrowAmount);
            if (allowed != 0) {
                revert BorrowComptrollerRejection(allowed);
            }
    
            /* Verify market's block number equals current block number */
            if (accrualBlockNumber != getBlockNumber()) {
                revert BorrowFreshnessCheck();
            }
    
            /* Fail gracefully if protocol has insufficient underlying cash */
            if (getCashPrior() < borrowAmount) {
                revert BorrowCashNotAvailable();
            }
    
            /*
             * We calculate the new borrower and total borrow balances, failing on overflow:
             *  accountBorrowNew = accountBorrow + borrowAmount
             *  totalBorrowsNew = totalBorrows + borrowAmount
             */
            uint accountBorrowsPrev = borrowBalanceStoredInternal(borrower);
            uint accountBorrowsNew = accountBorrowsPrev + borrowAmount;
            uint totalBorrowsNew = totalBorrows + borrowAmount;
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            /*
             * We write the previously calculated values into storage.
             *  Note: Avoid token reentrancy attacks by writing increased borrow before external transfer.
            `*/
            accountBorrows[borrower].principal = accountBorrowsNew;
            accountBorrows[borrower].interestIndex = borrowIndex;
            totalBorrows = totalBorrowsNew;
    
            /*
             * We invoke doTransferOut for the borrower and the borrowAmount.
             *  Note: The cToken must handle variations between ERC-20 and ETH underlying.
             *  On success, the cToken borrowAmount less of cash.
             *  doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.
             */
            doTransferOut(borrower, borrowAmount);
    
            /* We emit a Borrow event */
            emit Borrow(borrower, borrowAmount, accountBorrowsNew, totalBorrowsNew);
        }
    

![img](https://storage.googleapis.com/papyrus_images/584f20269b6e3ee46d72fc20db33ed4d1db55c85e58871dbd829aa03b7f71989.png)

img

#### repayBorrow函数

borrower->pay token->compound

还款，当指定还款金额为 -1 时，则表示全额还款，包括所有利息，否则，则会存在利息没还尽的可能，因为每过一个区块就会产生新的利息。

    //cERC20.sol
          /**
         * @notice Sender repays their own borrow
         * @param repayAmount The amount to repay, or -1 for the full outstanding amount
         * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
         */
        function repayBorrow(uint repayAmount) override external returns (uint) {
            repayBorrowInternal(repayAmount);
            return NO_ERROR;
        }
    
    
    //cToken.sol repayBorrowInternal
    
    //偿付自己的债务
             /**
         * @notice Sender repays their own borrow
         * @param repayAmount The amount to repay, or -1 for the full outstanding amount
         */
        function repayBorrowInternal(uint repayAmount) internal nonReentrant {
            accrueInterest();
            // repayBorrowFresh emits repay-borrow-specific logs on errors, so we don't need to
            repayBorrowFresh(msg.sender, msg.sender, repayAmount);
        }
    
    
    //代为偿还他人的债务
        /**
         * @notice Sender repays a borrow belonging to borrower
         * @param borrower the account with the debt being payed off
         * @param repayAmount The amount to repay, or -1 for the full outstanding amount
         */
        function repayBorrowBehalfInternal(address borrower, uint repayAmount) internal nonReentrant {
            accrueInterest();
            // repayBorrowFresh emits repay-borrow-specific logs on errors, so we don't need to
            repayBorrowFresh(msg.sender, borrower, repayAmount);
        }
    
    
    
    //cToken.sol repayBorrowFresh
      /**
         * @notice Borrows are repaid by another user (possibly the borrower).
         * @param payer the account paying off the borrow
         * @param borrower the account with the debt being payed off
         * @param repayAmount the amount of underlying tokens being returned, or -1 for the full outstanding amount
         * @return (uint) the actual repayment amount.
         */
        function repayBorrowFresh(address payer, address borrower, uint repayAmount) internal returns (uint) {
            /* Fail if repayBorrow not allowed */
            uint allowed = comptroller.repayBorrowAllowed(address(this), payer, borrower, repayAmount);
            if (allowed != 0) {
                revert RepayBorrowComptrollerRejection(allowed);
            }
    
            /* Verify market's block number equals current block number */
            if (accrualBlockNumber != getBlockNumber()) {
                revert RepayBorrowFreshnessCheck();
            }
    
            /* We fetch the amount the borrower owes, with accumulated interest */
            uint accountBorrowsPrev = borrowBalanceStoredInternal(borrower);
    
            /* If repayAmount == -1, repayAmount = accountBorrows */
            uint repayAmountFinal = repayAmount == type(uint).max ? accountBorrowsPrev : repayAmount;
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            /*
             * We call doTransferIn for the payer and the repayAmount
             *  Note: The cToken must handle variations between ERC-20 and ETH underlying.
             *  On success, the cToken holds an additional repayAmount of cash.
             *  doTransferIn reverts if anything goes wrong, since we can't be sure if side effects occurred.
             *   it returns the amount actually transferred, in case of a fee.
             */
            uint actualRepayAmount = doTransferIn(payer, repayAmountFinal);
    
            /*
             * We calculate the new borrower and total borrow balances, failing on underflow:
             *  accountBorrowsNew = accountBorrows - actualRepayAmount
             *  totalBorrowsNew = totalBorrows - actualRepayAmount
             */
            uint accountBorrowsNew = accountBorrowsPrev - actualRepayAmount;
            uint totalBorrowsNew = totalBorrows - actualRepayAmount;
    
            /* We write the previously calculated values into storage */
            accountBorrows[borrower].principal = accountBorrowsNew;
            accountBorrows[borrower].interestIndex = borrowIndex;
            totalBorrows = totalBorrowsNew;
    
            /* We emit a RepayBorrow event */
            emit RepayBorrow(payer, borrower, actualRepayAmount, accountBorrowsNew, totalBorrowsNew);
    
            return actualRepayAmount;
        }
    

![img](https://storage.googleapis.com/papyrus_images/fc161c433661cca1dce840c8692287c217b971303a96ef2f2de56c83381bdb33.png)

img

#### liquidate函数

token In,cToken out

    //cErc20.sol
        /**
         * @notice The sender liquidates the borrowers collateral.
         *  The collateral seized is transferred to the liquidator.
         * @param borrower The borrower of this cToken to be liquidated
         * @param repayAmount The amount of the underlying borrowed asset to repay
         * @param cTokenCollateral The market in which to seize collateral from the borrower
         * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
         */
        function liquidateBorrow(address borrower, uint repayAmount, CTokenInterface cTokenCollateral) override external returns (uint) {
            liquidateBorrowInternal(borrower, repayAmount, cTokenCollateral);
            return NO_ERROR;
        }
    
    
    //cToken.sol liquidateBorrowInternal
    /**
         * @notice The sender liquidates the borrowers collateral.
         *  The collateral seized is transferred to the liquidator.
         * @param borrower The borrower of this cToken to be liquidated
         * @param cTokenCollateral The market in which to seize collateral from the borrower
         * @param repayAmount The amount of the underlying borrowed asset to repay
         */
        function liquidateBorrowInternal(address borrower, uint repayAmount, CTokenInterface cTokenCollateral) internal nonReentrant {
            accrueInterest();
    
            uint error = cTokenCollateral.accrueInterest();
            if (error != NO_ERROR) {
                // accrueInterest emits logs on errors, but we still want to log the fact that an attempted liquidation failed
                revert LiquidateAccrueCollateralInterestFailed(error);
            }
    
            // liquidateBorrowFresh emits borrow-specific logs on errors, so we don't need to
            liquidateBorrowFresh(msg.sender, borrower, repayAmount, cTokenCollateral);
        }
    
    
    
    
    //cToken.sol liquidateBorrowsFresh
       /**
         * @notice The liquidator liquidates the borrowers collateral.
         *  The collateral seized is transferred to the liquidator.
         * @param borrower The borrower of this cToken to be liquidated
         * @param liquidator The address repaying the borrow and seizing collateral
         * @param cTokenCollateral The market in which to seize collateral from the borrower
         * @param repayAmount The amount of the underlying borrowed asset to repay
         */
        function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, CTokenInterface cTokenCollateral) internal {
            /* Fail if liquidate not allowed */
            uint allowed = comptroller.liquidateBorrowAllowed(address(this), address(cTokenCollateral), liquidator, borrower, repayAmount);
            if (allowed != 0) {
                revert LiquidateComptrollerRejection(allowed);
            }
    
            /* Verify market's block number equals current block number */
            if (accrualBlockNumber != getBlockNumber()) {
                revert LiquidateFreshnessCheck();
            }
    
            /* Verify cTokenCollateral market's block number equals current block number */
            if (cTokenCollateral.accrualBlockNumber() != getBlockNumber()) {
                revert LiquidateCollateralFreshnessCheck();
            }
    
            /* Fail if borrower = liquidator */
            if (borrower == liquidator) {
                revert LiquidateLiquidatorIsBorrower();
            }
    
            /* Fail if repayAmount = 0 */
            if (repayAmount == 0) {
                revert LiquidateCloseAmountIsZero();
            }
    
            /* Fail if repayAmount = -1 */
            if (repayAmount == type(uint).max) {
                revert LiquidateCloseAmountIsUintMax();
            }
    
            /* Fail if repayBorrow fails */
            uint actualRepayAmount = repayBorrowFresh(liquidator, borrower, repayAmount);
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            /* We calculate the number of collateral tokens that will be seized */
            (uint amountSeizeError, uint seizeTokens) = comptroller.liquidateCalculateSeizeTokens(address(this), address(cTokenCollateral), actualRepayAmount);
            require(amountSeizeError == NO_ERROR, "LIQUIDATE_COMPTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED");
    
            /* Revert if borrower collateral token balance < seizeTokens */
            require(cTokenCollateral.balanceOf(borrower) >= seizeTokens, "LIQUIDATE_SEIZE_TOO_MUCH");
    
            // If this is also the collateral, run seizeInternal to avoid re-entrancy, otherwise make an external call
            if (address(cTokenCollateral) == address(this)) {
                seizeInternal(address(this), liquidator, borrower, seizeTokens);
            } else {
                require(cTokenCollateral.seize(liquidator, borrower, seizeTokens) == NO_ERROR, "token seizure failed");
            }
    
            /* We emit a LiquidateBorrow event */
            emit LiquidateBorrow(liquidator, borrower, actualRepayAmount, address(cTokenCollateral), seizeTokens);
        }
    

#### accrueInterest 函数

计算更新利息

     /**
         * @notice Applies accrued interest to total borrows and reserves
         * @dev This calculates interest accrued from the last checkpointed block
         *   up to the current block and writes new checkpoint to storage.
         */
        function accrueInterest() virtual override public returns (uint) {
            /* Remember the initial block number */
            uint currentBlockNumber = getBlockNumber();
            uint accrualBlockNumberPrior = accrualBlockNumber;
    
            /* Short-circuit accumulating 0 interest */
              /*获取当前区块 crrentBlockNumber 和最近一次计算的区块 accrualBlockNumberPrior，如果两个区块相等，
              表示当前区块已经计算过利息，无需再计算，直接返回*/
            if (accrualBlockNumberPrior == currentBlockNumber) {
                return NO_ERROR;
            }
    
            /* Read the previous values out of storage */
              /*
              获取保存的 cash（资金池余额）、totalBorrows（总借款）、totalReserves（总储备金）、borrowIndex（借款指数）
              */
            uint cashPrior = getCashPrior();
            uint borrowsPrior = totalBorrows;
            uint reservesPrior = totalReserves;
            uint borrowIndexPrior = borrowIndex;
    
            /* Calculate the current borrow interest rate */
          
              //调用 interestRateModel.getBorrowRate() 得到借款利率 borrowRate
            uint borrowRateMantissa = interestRateModel.getBorrowRate(cashPrior, borrowsPrior, reservesPrior);
            //如果 borrowRate 超过最大的借款利率，则错误退出，否则进入下一步
              require(borrowRateMantissa <= borrowRateMaxMantissa, "borrow rate is absurdly high");
    
            /* Calculate the number of blocks elapsed since the last accrual */
            //计算当前区块和 accrualBlockNumberPrior 之间的区块数 blockDelta，该区块数即是还未计算利息的区块区间。
              uint blockDelta = currentBlockNumber - accrualBlockNumberPrior;
    
            /*
             * Calculate the interest accumulated into borrows and reserves and the new index:
             *  simpleInterestFactor = borrowRate * blockDelta  区块区间内的单位利息
             *  interestAccumulated = simpleInterestFactor * totalBorrows  表示总借款在该区块区间内产生的总利息
             *  totalBorrowsNew = interestAccumulated + totalBorrows  将总利息累加到总借款中
             *  totalReservesNew = interestAccumulated * reserveFactor + totalReserves  根据储备金率将部分利息累加到储备金中
             *  borrowIndexNew = simpleInterestFactor * borrowIndex + borrowIndex  累加借款指数
             */
    
            Exp memory simpleInterestFactor = mul_(Exp({mantissa: borrowRateMantissa}), blockDelta);
            uint interestAccumulated = mul_ScalarTruncate(simpleInterestFactor, borrowsPrior);
            uint totalBorrowsNew = interestAccumulated + borrowsPrior;
            uint totalReservesNew = mul_ScalarTruncateAddUInt(Exp({mantissa: reserveFactorMantissa}), interestAccumulated, reservesPrior);
            uint borrowIndexNew = mul_ScalarTruncateAddUInt(simpleInterestFactor, borrowIndexPrior, borrowIndexPrior);
    
            /////////////////////////
            // EFFECTS & INTERACTIONS
            // (No safe failures beyond this point)
    
            /* We write the previously calculated values into storage */
            accrualBlockNumber = currentBlockNumber;
            borrowIndex = borrowIndexNew;
            totalBorrows = totalBorrowsNew;
            totalReserves = totalReservesNew;
    
            /* We emit an AccrueInterest event */
            emit AccrueInterest(cashPrior, interestAccumulated, borrowIndexNew, totalBorrowsNew);
    
            return NO_ERROR;
        }
    

#### 治理

后续分析

#### 参考链接

[https://learnblockchain.cn/article/2781](https://learnblockchain.cn/article/2781)

[https://learnblockchain.cn/people/96](https://learnblockchain.cn/people/96)

[https://learnblockchain.cn/article/3165](https://learnblockchain.cn/article/3165)

[![]({{DOMAIN}}/editor/youtube/play.png)](https://www.youtube.com/watch?v=CnFLT-xTf8I)

[https://docs.compound.finance/v2/](https://docs.compound.finance/v2/)

[https://www.odaily.news/post/5181268](https://www.odaily.news/post/5181268)

[https://medium.com/steaker-com/defi-的世界-compound-完全解析-利率模型篇-95e9b303c284](https://medium.com/steaker-com/defi-%E7%9A%84%E4%B8%96%E7%95%8C-compound-%E5%AE%8C%E5%85%A8%E8%A7%A3%E6%9E%90-%E5%88%A9%E7%8E%87%E6%A8%A1%E5%9E%8B%E7%AF%87-95e9b303c284)

[https://learnblockchain.cn/article/2802](https://learnblockchain.cn/article/2802)

---

*Originally published on [d1rrick](https://paragraph.com/@d1rrick/compound)*