Liquidity Tests

- Added a check on strategy withdrawal to ensure that redeeming aTokens or cTokens results in stablecoin withdrawals
- Added `getLendingPeriods` to `ILiquidityEngine`
- Refactored `getLendingPeriodKey` and `getWithdrawalWindowKey` on StrategyLibV1 to drop `ignoreMissingKey` check
- Added more tests to increase coverage

contracts/core/delegates/VaultDelegateBase.sol

@@ -95,7 +95,7 @@ abstract contract VaultDelegateBase is IVaultDelegate, Recoverable {
     IERC20, /*token*/
     bytes32 coverKey,
     bytes32 strategyName,
-    uint256 amount
+    uint256 /*amount*/
   ) external override nonReentrant {
     s.mustNotBePaused();
     s.senderMustBeVaultContract(coverKey);

contracts/core/liquidity/LiquidityEngine.sol

@@ -64,6 +64,10 @@ contract LiquidityEngine is ILiquidityEngine, Recoverable {
     s.setLendingPeriodsInternal(0, lendingPeriod, withdrawalWindow);
   }
 
+  function getLendingPeriods(bytes32 coverKey) external view override returns (uint256 lendingPeriod, uint256 withdrawalWindow) {
+    return s.getLendingPeriodsInternal(coverKey);
+  }
+
   function getDisabledStrategies() external view override returns (address[] memory strategies) {
     return s.getDisabledStrategiesInternal();
   }

contracts/core/liquidity/strategies/AaveStrategy.sol

@@ -154,6 +154,8 @@ contract AaveStrategy is ILendingStrategy, Recoverable {
     // Check how many DAI we received
     stablecoinWithdrawn = stablecoin.balanceOf(address(this));
 
+    require(stablecoinWithdrawn > 0, "Redeeming aToken failed");
+
     // Immediately send DAI to the vault aToken came from
     stablecoin.ensureApproval(address(vault), stablecoinWithdrawn);
     vault.receiveFromStrategy(stablecoin, coverKey, getName(), stablecoinWithdrawn);
@@ -177,7 +179,7 @@ contract AaveStrategy is ILendingStrategy, Recoverable {
     return keccak256(abi.encodePacked(_KEY, coverKey, NS_WITHDRAWALS));
   }
 
-  function getWeight() external pure override returns (uint256) {
+  function getWeight() external pure virtual override returns (uint256) {
     return 10_000; // 100%
   }
 

contracts/core/liquidity/strategies/CompoundStrategy.sol

@@ -156,6 +156,8 @@ contract CompoundStrategy is ILendingStrategy, Recoverable {
     // Check how many DAI we received
     stablecoinWithdrawn = stablecoin.balanceOf(address(this));
 
+    require(stablecoinWithdrawn > 0, "Redeeming cDai failed");
+
     // Immediately send DAI to the vault cDAI came from
     stablecoin.ensureApproval(address(vault), stablecoinWithdrawn);
     vault.receiveFromStrategy(stablecoin, coverKey, getName(), stablecoinWithdrawn);

contracts/fakes/FakeCompoundERC20Delegator.sol → contracts/fakes/FakeCompoundDaiDelegator.sol

@@ -5,7 +5,7 @@ import "../interfaces/external/ICompoundERC20DelegatorLike.sol";
 import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
 import "./FakeToken.sol";
 
-contract FakeCompoundERC20Delegator is ICompoundERC20DelegatorLike, ERC20 {
+contract FakeCompoundDaiDelegator is ICompoundERC20DelegatorLike, ERC20 {
   FakeToken public dai;
   FakeToken public cDai;
 

contracts/fakes/FaultyAaveLendingPool.sol

@@ -0,0 +1,32 @@
+// Neptune Mutual Protocol (https://neptunemutual.com)
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.0;
+import "../interfaces/external/IAaveV2LendingPoolLike.sol";
+import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
+import "./FakeToken.sol";
+
+contract FaultyAaveLendingPool is IAaveV2LendingPoolLike, ERC20 {
+  FakeToken public aToken;
+
+  constructor(FakeToken _aToken) ERC20("aDAI", "aDAI") {
+    aToken = _aToken;
+  }
+
+  function deposit(
+    address asset,
+    uint256 amount,
+    address,
+    uint16
+  ) external override {
+    IERC20(asset).transferFrom(msg.sender, address(this), amount);
+  }
+
+  function withdraw(
+    address, /*asset*/
+    uint256 amount,
+    address /*to*/
+  ) external override returns (uint256) {
+    aToken.transferFrom(msg.sender, address(this), amount);
+    return amount;
+  }
+}

contracts/fakes/FaultyCompoundDaiDelegator.sol

@@ -0,0 +1,48 @@
+// Neptune Mutual Protocol (https://neptunemutual.com)
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.0;
+import "../interfaces/external/ICompoundERC20DelegatorLike.sol";
+import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
+import "./FakeToken.sol";
+
+contract FaultyCompoundDaiDelegator is ICompoundERC20DelegatorLike, ERC20 {
+  FakeToken public dai;
+  FakeToken public cDai;
+  uint256 public returnValue;
+
+  function setReturnValue(uint256 _returnValue) external {
+    returnValue = _returnValue;
+  }
+
+  constructor(
+    FakeToken _dai,
+    FakeToken _cDai,
+    uint256 _returnValue
+  ) ERC20("cDAI", "cDAI") {
+    dai = _dai;
+    cDai = _cDai;
+    returnValue = _returnValue;
+  }
+
+  /**
+   * @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(uint256 mintAmount) external override returns (uint256) {
+    dai.transferFrom(msg.sender, address(this), mintAmount);
+    return returnValue;
+  }
+
+  /**
+   * @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(uint256 redeemTokens) external override returns (uint256) {
+    cDai.transferFrom(msg.sender, address(this), redeemTokens);
+    return returnValue;
+  }
+}

contracts/fakes/InvalidStrategy.sol

@@ -0,0 +1,17 @@
+// Neptune Mutual Protocol (https://neptunemutual.com)
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.0;
+
+import "../core/liquidity/strategies/AaveStrategy.sol";
+
+contract InvalidStrategy is AaveStrategy {
+  constructor(
+    IStore _s,
+    IAaveV2LendingPoolLike _lendingPool,
+    address _aToken
+  ) AaveStrategy(_s, _lendingPool, _aToken) {} // solhint-disable-line
+
+  function getWeight() external pure override returns (uint256) {
+    return 20_000; // 100%
+  }
+}

contracts/interfaces/ILiquidityEngine.sol

@@ -23,6 +23,8 @@ interface ILiquidityEngine is IMember {
 
   function setLendingPeriodsDefault(uint256 lendingPeriod, uint256 withdrawalWindow) external;
 
+  function getLendingPeriods(bytes32 coverKey) external view returns (uint256 lendingPeriod, uint256 withdrawalWindow);
+
   function setLiquidityStateUpdateInterval(uint256 value) external;
 
   function getDisabledStrategies() external view returns (address[] memory strategies);

contracts/libraries/PriceLibV1.sol

@@ -90,12 +90,12 @@ library PriceLibV1 {
     return (2 * reserve1 * lpTokens) / supply;
   }
 
-  function getLastUpdateOnInternal(IStore s) public view returns (uint256) {
+  function getLastUpdateOnInternal(IStore s) external view returns (uint256) {
     bytes32 key = getLastUpdateKey();
     return s.getUintByKey(key);
   }
 
-  function setLastUpdateOn(IStore s) public {
+  function setLastUpdateOn(IStore s) external {
     bytes32 key = getLastUpdateKey();
     s.setUintByKey(key, block.timestamp); // solhint-disable-line
   }

contracts/libraries/StrategyLibV1.sol

@@ -38,12 +38,12 @@ library StrategyLibV1 {
   }
 
   function getLendingPeriodsInternal(IStore s, bytes32 coverKey) external view returns (uint256 lendingPeriod, uint256 withdrawalWindow) {
-    lendingPeriod = s.getUintByKey(getLendingPeriodKey(coverKey, true));
-    withdrawalWindow = s.getUintByKey(getWithdrawalWindowKey(coverKey, true));
+    lendingPeriod = s.getUintByKey(getLendingPeriodKey(coverKey));
+    withdrawalWindow = s.getUintByKey(getWithdrawalWindowKey(coverKey));
 
     if (lendingPeriod == 0) {
-      lendingPeriod = s.getUintByKey(getLendingPeriodKey(0, true));
-      withdrawalWindow = s.getUintByKey(getWithdrawalWindowKey(0, true));
+      lendingPeriod = s.getUintByKey(getLendingPeriodKey(0));
+      withdrawalWindow = s.getUintByKey(getWithdrawalWindowKey(0));
     }
   }
 
@@ -53,29 +53,21 @@ library StrategyLibV1 {
     uint256 lendingPeriod,
     uint256 withdrawalWindow
   ) external {
-    s.setUintByKey(getLendingPeriodKey(coverKey, true), lendingPeriod);
-    s.setUintByKey(getWithdrawalWindowKey(coverKey, true), withdrawalWindow);
+    s.setUintByKey(getLendingPeriodKey(coverKey), lendingPeriod);
+    s.setUintByKey(getWithdrawalWindowKey(coverKey), withdrawalWindow);
 
     emit LendingPeriodSet(lendingPeriod, withdrawalWindow);
   }
 
-  function getLendingPeriodKey(bytes32 coverKey, bool ignoreMissingKey) public pure returns (bytes32) {
-    if (ignoreMissingKey == false) {
-      require(coverKey > 0, "Invalid Cover Key");
-    }
-
+  function getLendingPeriodKey(bytes32 coverKey) public pure returns (bytes32) {
     if (coverKey > 0) {
       return keccak256(abi.encodePacked(ProtoUtilV1.NS_COVER_LIQUIDITY_LENDING_PERIOD, coverKey));
     }
 
     return ProtoUtilV1.NS_COVER_LIQUIDITY_LENDING_PERIOD;
   }
 
-  function getWithdrawalWindowKey(bytes32 coverKey, bool ignoreMissingKey) public pure returns (bytes32) {
-    if (ignoreMissingKey == false) {
-      require(coverKey > 0, "Invalid Cover Key");
-    }
-
+  function getWithdrawalWindowKey(bytes32 coverKey) public pure returns (bytes32) {
     if (coverKey > 0) {
       return keccak256(abi.encodePacked(ProtoUtilV1.NS_COVER_LIQUIDITY_WITHDRAWAL_WINDOW, coverKey));
     }

test/specs/liquidity/engine/add-strategies.spec.js

@@ -117,6 +117,25 @@ describe('Liquidity Engine: addStrategies', () => {
     await liquidityEngine.connect(bob).addStrategies([aaveStrategy.address]).should.be.rejectedWith('Forbidden')
   })
 
+  it('reverts when too much weight is specified', async () => {
+    const aToken = await deployer.deploy(cache, 'FakeToken', 'Neptune Mutual Token', 'NPM', helper.ether(100_000_000))
+
+    const aaveLendingPool = await deployer.deploy(cache, 'FakeAaveLendingPool', aToken.address)
+
+    const invalidStrategy = await deployer.deployWithLibraries(cache, 'InvalidStrategy', {
+      AccessControlLibV1: accessControlLibV1.address,
+      BaseLibV1: baseLibV1.address,
+      NTransferUtilV2: transferLib.address,
+      ProtoUtilV1: protoUtilV1.address,
+      RegistryLibV1: registryLibV1.address,
+      StoreKeyUtil: storeKeyUtil.address,
+      ValidationLibV1: validationLibV1.address
+    }, store.address, aaveLendingPool.address, aToken.address)
+
+    await deployed.protocol.addContract(key.PROTOCOL.CNS.STRATEGY_AAVE, invalidStrategy.address)
+    await liquidityEngine.addStrategies([invalidStrategy.address]).should.be.rejectedWith('Weight too much')
+  })
+
   it('reverts when protocol is paused', async () => {
     const aToken = await deployer.deploy(cache, 'FakeToken', 'Neptune Mutual Token', 'NPM', helper.ether(100_000_000))
 

test/specs/liquidity/engine/disable-strategy.spec.js

@@ -75,6 +75,11 @@ describe('Liquidity Engine: disableStrategy', () => {
     event.args.strategy.should.equal(aaveStrategy.address)
   })
 
+  it('must throw while disabling an invalid strategy', async () => {
+    await liquidityEngine.disableStrategy(helper.randomAddress())
+      .should.be.rejectedWith('Invalid strategy')
+  })
+
   it('correctly get disabled strategies', async () => {
     await liquidityEngine.disableStrategy(aaveStrategy.address)
     const disabledStrategies = await liquidityEngine.getDisabledStrategies()

test/specs/liquidity/engine/set-lending-periods-default.spec.js

@@ -51,6 +51,10 @@ describe('Liquidity Engine: `setLendingPeriodsDefault` function', () => {
 
     event.args.lendingPeriod.should.equal(lendingPeriod)
     event.args.withdrawalWindow.should.equal(withdrawalWindow)
+
+    const result = await liquidityEngine.getLendingPeriods(key.toBytes32(''))
+    result[0].should.equal(lendingPeriod)
+    result[1].should.equal(withdrawalWindow)
   })
 
   it('reverts when protocol is paused', async () => {

test/specs/liquidity/engine/set-lending-periods.spec.js

@@ -41,6 +41,12 @@ describe('Liquidity Engine: `setLendingPeriods` function', () => {
     await deployed.protocol.addContract(key.PROTOCOL.CNS.LIQUIDITY_ENGINE, liquidityEngine.address)
   })
 
+  it('correct gets the lending period', async () => {
+    const result = await liquidityEngine.getLendingPeriods(coverkey)
+    result[0].should.equal('0')
+    result[1].should.equal('0')
+  })
+
   it('correctly sets lending period', async () => {
     const lendingPeriod = '10'
     const withdrawalWindow = '10'
@@ -52,6 +58,10 @@ describe('Liquidity Engine: `setLendingPeriods` function', () => {
 
     event.args.lendingPeriod.should.equal(lendingPeriod)
     event.args.withdrawalWindow.should.equal(withdrawalWindow)
+
+    const result = await liquidityEngine.getLendingPeriods(coverkey)
+    result[0].should.equal(lendingPeriod)
+    result[1].should.equal(withdrawalWindow)
   })
 
   it('reverts when protocol is paused', async () => {

test/specs/liquidity/strategy/aave/ctor.spec.js

@@ -0,0 +1,37 @@
+/* eslint-disable no-unused-expressions */
+const BigNumber = require('bignumber.js')
+const { deployer, key, helper } = require('../../../../../util')
+const { deployDependencies } = require('../deps')
+const cache = null
+
+require('chai')
+  .use(require('chai-as-promised'))
+  .use(require('chai-bignumber')(BigNumber))
+  .should()
+
+describe('Aave Strategy Constructor', () => {
+  let deployed, aaveLendingPool, aToken
+
+  beforeEach(async () => {
+    deployed = await deployDependencies()
+
+    aToken = await deployer.deploy(cache, 'FakeToken', 'aToken', 'aToken', helper.ether(100_000_000))
+    aaveLendingPool = await deployer.deploy(cache, 'FakeAaveLendingPool', aToken.address)
+  })
+
+  it('correctly deploys', async () => {
+    const aaveStrategy = await deployer.deployWithLibraries(cache, 'AaveStrategy', {
+      AccessControlLibV1: deployed.accessControlLibV1.address,
+      BaseLibV1: deployed.baseLibV1.address,
+      NTransferUtilV2: deployed.transferLib.address,
+      ProtoUtilV1: deployed.protoUtilV1.address,
+      RegistryLibV1: deployed.registryLibV1.address,
+      StoreKeyUtil: deployed.storeKeyUtil.address,
+      ValidationLibV1: deployed.validationLibV1.address
+    }, deployed.store.address, aaveLendingPool.address, aToken.address)
+
+   ; (await aaveStrategy.getKey()).should.equal(ethers.utils.solidityKeccak256(['string', 'string', 'string', 'string'], ['lending', 'strategy', 'aave', 'v2']))
+    ; (await aaveStrategy.version()).should.equal(key.toBytes32('v0.1'))
+    ; (await aaveStrategy.getName()).should.equal(key.PROTOCOL.CNAME.STRATEGY_AAVE)
+  })
+})