Add STETH to Aave V2

README.md

@@ -119,6 +119,17 @@ docker-compose exec contracts-env bash
 npm run test
 ```
 
+## Test StETH Integration
+
+To run tests for StETH integration use the following commands:
+
+```
+npm install
+npm run compile
+npm run test:steth
+npm run test:steth-coverage # to run tests with coverage report
+```
+
 ## Deployments
 
 For deploying Aave Protocol V2, you can use the available scripts located at `package.json`. For a complete list, run `npm run` to see all the tasks.

contracts/mocks/tokens/StETHMocked.sol

@@ -0,0 +1,276 @@
+// SPDX-FileCopyrightText: 2020 Lido <[email protected]>
+pragma solidity 0.6.12;
+
+/**
+ * @notice Mock was based on the original StETH contract from the Lido organization
+ * https://github.com/lidofinance/lido-dao/blob/master/contracts/0.4.24/StETH.sol
+ * and tries to be as close as possible to the original implementation.
+ */
+contract StETHMocked {
+  using LidoSafeMath for uint256;
+
+  // use there values like real stETH has
+  uint256 internal _totalShares = 1608965089698263670456320;
+  uint256 internal _pooledEther = 1701398689820002221426255;
+  mapping(address => uint256) private shares;
+  mapping(address => mapping(address => uint256)) private allowances;
+
+  function name() public pure returns (string memory) {
+    return 'Liquid staked Ether 2.0';
+  }
+
+  function symbol() public pure returns (string memory) {
+    return 'stETH';
+  }
+
+  function decimals() public pure returns (uint8) {
+    return 18;
+  }
+
+  function totalSupply() public view returns (uint256) {
+    return _getTotalPooledEther();
+  }
+
+  function getTotalPooledEther() public view returns (uint256) {
+    return _getTotalPooledEther();
+  }
+
+  function balanceOf(address _account) public view returns (uint256) {
+    return getPooledEthByShares(_sharesOf(_account));
+  }
+
+  function transfer(address _recipient, uint256 _amount) public returns (bool) {
+    _transfer(msg.sender, _recipient, _amount);
+    return true;
+  }
+
+  function allowance(address _owner, address _spender) public view returns (uint256) {
+    return allowances[_owner][_spender];
+  }
+
+  function approve(address _spender, uint256 _amount) public returns (bool) {
+    _approve(msg.sender, _spender, _amount);
+    return true;
+  }
+
+  function transferFrom(
+    address _sender,
+    address _recipient,
+    uint256 _amount
+  ) public returns (bool) {
+    uint256 currentAllowance = allowances[_sender][msg.sender];
+    require(currentAllowance >= _amount, 'TRANSFER_AMOUNT_EXCEEDS_ALLOWANCE');
+
+    _transfer(_sender, _recipient, _amount);
+    _approve(_sender, msg.sender, currentAllowance.sub(_amount));
+    return true;
+  }
+
+  function increaseAllowance(address _spender, uint256 _addedValue) public returns (bool) {
+    _approve(msg.sender, _spender, allowances[msg.sender][_spender].add(_addedValue));
+    return true;
+  }
+
+  function decreaseAllowance(address _spender, uint256 _subtractedValue) public returns (bool) {
+    uint256 currentAllowance = allowances[msg.sender][_spender];
+    require(currentAllowance >= _subtractedValue, 'DECREASED_ALLOWANCE_BELOW_ZERO');
+    _approve(msg.sender, _spender, currentAllowance.sub(_subtractedValue));
+    return true;
+  }
+
+  function getTotalShares() public view returns (uint256) {
+    return _getTotalShares();
+  }
+
+  function sharesOf(address _account) public view returns (uint256) {
+    return _sharesOf(_account);
+  }
+
+  function getSharesByPooledEth(uint256 _ethAmount) public view returns (uint256) {
+    uint256 totalPooledEther = _getTotalPooledEther();
+    if (totalPooledEther == 0) {
+      return 0;
+    } else {
+      return _ethAmount.mul(_getTotalShares()).div(totalPooledEther);
+    }
+  }
+
+  function getPooledEthByShares(uint256 _sharesAmount) public view returns (uint256) {
+    uint256 totalShares = _getTotalShares();
+    if (totalShares == 0) {
+      return 0;
+    } else {
+      return _sharesAmount.mul(_getTotalPooledEther()).div(totalShares);
+    }
+  }
+
+  function mint(address _recipient, uint256 amount) external returns (uint256) {
+    return _submit(_recipient, amount);
+  }
+
+  function positiveRebase(uint256 amount) external {
+    _pooledEther = _pooledEther.add(amount);
+  }
+
+  function negativeRebase(uint256 amount) external {
+    _pooledEther = _pooledEther.sub(amount);
+  }
+
+  function _getTotalPooledEther() internal view returns (uint256) {
+    return _pooledEther;
+  }
+
+  function _transfer(
+    address _sender,
+    address _recipient,
+    uint256 _amount
+  ) internal {
+    uint256 _sharesToTransfer = getSharesByPooledEth(_amount);
+    _transferShares(_sender, _recipient, _sharesToTransfer);
+    emit Transfer(_sender, _recipient, _amount);
+  }
+
+  function _approve(
+    address _owner,
+    address _spender,
+    uint256 _amount
+  ) internal {
+    require(_owner != address(0), 'APPROVE_FROM_ZERO_ADDRESS');
+    require(_spender != address(0), 'APPROVE_TO_ZERO_ADDRESS');
+
+    allowances[_owner][_spender] = _amount;
+    emit Approval(_owner, _spender, _amount);
+  }
+
+  function _getTotalShares() internal view returns (uint256) {
+    return _totalShares;
+  }
+
+  function _sharesOf(address _account) internal view returns (uint256) {
+    return shares[_account];
+  }
+
+  function _transferShares(
+    address _sender,
+    address _recipient,
+    uint256 _sharesAmount
+  ) internal {
+    require(_sender != address(0), 'TRANSFER_FROM_THE_ZERO_ADDRESS');
+    require(_recipient != address(0), 'TRANSFER_TO_THE_ZERO_ADDRESS');
+
+    uint256 currentSenderShares = shares[_sender];
+    require(_sharesAmount <= currentSenderShares, 'TRANSFER_AMOUNT_EXCEEDS_BALANCE');
+
+    shares[_sender] = currentSenderShares.sub(_sharesAmount);
+    shares[_recipient] = shares[_recipient].add(_sharesAmount);
+  }
+
+  function _mintShares(address _recipient, uint256 _sharesAmount)
+    internal
+    returns (uint256 newTotalShares)
+  {
+    require(_recipient != address(0), 'MINT_TO_THE_ZERO_ADDRESS');
+
+    newTotalShares = _getTotalShares().add(_sharesAmount);
+    _totalShares = newTotalShares;
+
+    shares[_recipient] = shares[_recipient].add(_sharesAmount);
+  }
+
+  function _burnShares(address _account, uint256 _sharesAmount)
+    internal
+    returns (uint256 newTotalShares)
+  {
+    require(_account != address(0), 'BURN_FROM_THE_ZERO_ADDRESS');
+
+    uint256 accountShares = shares[_account];
+    require(_sharesAmount <= accountShares, 'BURN_AMOUNT_EXCEEDS_BALANCE');
+
+    newTotalShares = _getTotalShares().sub(_sharesAmount);
+    _totalShares = newTotalShares;
+
+    shares[_account] = accountShares.sub(_sharesAmount);
+  }
+
+  function _submit(address sender, uint256 deposit) internal returns (uint256) {
+    require(deposit != 0, 'ZERO_DEPOSIT');
+
+    uint256 sharesAmount = getSharesByPooledEth(deposit);
+    if (sharesAmount == 0) {
+      sharesAmount = deposit;
+    }
+
+    _mintShares(sender, sharesAmount);
+    _pooledEther = _pooledEther.add(deposit);
+    return sharesAmount;
+  }
+
+  event Transfer(address indexed from, address indexed to, uint256 value);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+/**
+ * @title SafeMath
+ * @dev Math operations with safety checks that revert on error. Prefix Lido used to not
+ * conflict with OpenZeppelin SafeMath contract.
+ */
+library LidoSafeMath {
+  string private constant ERROR_ADD_OVERFLOW = 'MATH_ADD_OVERFLOW';
+  string private constant ERROR_SUB_UNDERFLOW = 'MATH_SUB_UNDERFLOW';
+  string private constant ERROR_MUL_OVERFLOW = 'MATH_MUL_OVERFLOW';
+  string private constant ERROR_DIV_ZERO = 'MATH_DIV_ZERO';
+
+  /**
+   * @dev Multiplies two numbers, reverts on overflow.
+   */
+  function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    if (_a == 0) {
+      return 0;
+    }
+
+    uint256 c = _a * _b;
+    require(c / _a == _b, ERROR_MUL_OVERFLOW);
+
+    return c;
+  }
+
+  /**
+   * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
+   */
+  function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    require(_b > 0, ERROR_DIV_ZERO); // Solidity only automatically asserts when dividing by 0
+    uint256 c = _a / _b;
+    // assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
+
+    return c;
+  }
+
+  /**
+   * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
+   */
+  function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    require(_b <= _a, ERROR_SUB_UNDERFLOW);
+    uint256 c = _a - _b;
+
+    return c;
+  }
+
+  /**
+   * @dev Adds two numbers, reverts on overflow.
+   */
+  function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    uint256 c = _a + _b;
+    require(c >= _a, ERROR_ADD_OVERFLOW);
+
+    return c;
+  }
+
+  /**
+   * @dev Divides two numbers and returns the remainder (unsigned integer modulo),
+   * reverts when dividing by zero.
+   */
+  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
+    require(b != 0, ERROR_DIV_ZERO);
+    return a % b;
+  }
+}

contracts/protocol/tokenization/StableDebtToken.sol

@@ -103,7 +103,7 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
     address onBehalfOf,
     uint256 amount,
     uint256 rate
-  ) external override onlyLendingPool returns (bool) {
+  ) external virtual override onlyLendingPool returns (bool) {
     MintLocalVars memory vars;
 
     if (user != onBehalfOf) {

contracts/protocol/tokenization/VariableDebtToken.sol

@@ -62,7 +62,7 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
     address onBehalfOf,
     uint256 amount,
     uint256 index
-  ) external override onlyLendingPool returns (bool) {
+  ) external virtual override onlyLendingPool returns (bool) {
     if (user != onBehalfOf) {
       _decreaseBorrowAllowance(onBehalfOf, user, amount);
     }