dequanto 0.0.1 → 0.1.3

package/test/fixtures/parser/CToken/CToken.sol

@@ -0,0 +1,1156 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity ^0.8.10;
+
+import "./ComptrollerInterface.sol";
+import "./CTokenInterfaces.sol";
+import "./ErrorReporter.sol";
+import "./EIP20Interface.sol";
+import "./InterestRateModel.sol";
+import "./ExponentialNoError.sol";
+
+/**
+ * @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
+    }
+}