@ensuro/core 1.2.0 → 1.2.3

package/build/interfaces/IPolicyHolder.sol/IPolicyHolder.json

@@ -0,0 +1,108 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "IPolicyHolder",
+  "sourceName": "interfaces/IPolicyHolder.sol",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "operator",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "from",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "tokenId",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "data",
+          "type": "bytes"
+        }
+      ],
+      "name": "onERC721Received",
+      "outputs": [
+        {
+          "internalType": "bytes4",
+          "name": "",
+          "type": "bytes4"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "operator",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "from",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "policyId",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "name": "onPayoutReceived",
+      "outputs": [
+        {
+          "internalType": "bytes4",
+          "name": "",
+          "type": "bytes4"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "operator",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "from",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "policyId",
+          "type": "uint256"
+        }
+      ],
+      "name": "onPolicyExpired",
+      "outputs": [
+        {
+          "internalType": "bytes4",
+          "name": "",
+          "type": "bytes4"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "bytecode": "0x",
+  "deployedBytecode": "0x",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/build/interfaces/IPolicyPoolConfig.sol/IPolicyPoolConfig.json

@@ -184,6 +184,19 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "exchange",
+      "outputs": [
+        {
+          "internalType": "contract IExchange",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [
         {

package/contracts/AaveAssetManager.sol

@@ -1,18 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.0;
 
+import {AddressUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {BaseAssetManager} from "./BaseAssetManager.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
 import {IPolicyPoolConfig} from "../interfaces/IPolicyPoolConfig.sol";
+import {IExchange} from "../interfaces/IExchange.sol";
 import {WadRayMath} from "./WadRayMath.sol";
 import {ILendingPoolAddressesProvider} from "@aave/protocol-v2/contracts/interfaces/ILendingPoolAddressesProvider.sol";
 import {ILendingPool} from "@aave/protocol-v2/contracts/interfaces/ILendingPool.sol";
 import {IAToken} from "@aave/protocol-v2/contracts/interfaces/IAToken.sol";
-import {IPriceOracle} from "@aave/protocol-v2/contracts/interfaces/IPriceOracle.sol";
 import {AaveProtocolDataProvider} from "@aave/protocol-v2/contracts/misc/AaveProtocolDataProvider.sol";
-import {IUniswapV2Router02} from "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
 
 /**
  * @title AssetManager that reinvests the capital in AAVE
@@ -29,6 +29,7 @@ import {IUniswapV2Router02} from "@uniswap/v2-periphery/contracts/interfaces/IUn
 contract AaveAssetManager is BaseAssetManager {
   using SafeERC20 for IERC20Metadata;
   using WadRayMath for uint256;
+  using AddressUpgradeable for address;
 
   bytes32 public constant SWAP_REWARDS_ROLE = keccak256("SWAP_REWARDS_ROLE");
 
@@ -41,10 +42,8 @@ contract AaveAssetManager is BaseAssetManager {
   /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
   IERC20Metadata internal immutable _rewardToken;
   /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
-  IUniswapV2Router02 internal immutable _swapRouter; // We will use SushiSwap in Polygon
   uint256 internal _claimRewardsMin; // Minimum amount of rewards accumulated to claim
   uint256 internal _reinvestRewardsMin; // Minimum amount of rewards to reinvest into AAVE
-  uint256 internal _maxSlippage; // Maximum slippage in WAD
 
   bytes32 internal constant DATA_PROVIDER_ID =
     0x0100000000000000000000000000000000000000000000000000000000000000;
@@ -54,13 +53,10 @@ contract AaveAssetManager is BaseAssetManager {
   event RewardSwapped(uint256 rewardIn, uint256 currencyOut);
 
   /// @custom:oz-upgrades-unsafe-allow constructor
-  constructor(
-    IPolicyPool policyPool_,
-    ILendingPoolAddressesProvider aaveAddrProv_,
-    IUniswapV2Router02 swapRouter_
-  ) BaseAssetManager(policyPool_) {
+  constructor(IPolicyPool policyPool_, ILendingPoolAddressesProvider aaveAddrProv_)
+    BaseAssetManager(policyPool_)
+  {
     _aaveAddrProv = aaveAddrProv_;
-    _swapRouter = swapRouter_;
     AaveProtocolDataProvider dataProvider = AaveProtocolDataProvider(
       aaveAddrProv_.getAddress(DATA_PROVIDER_ID)
     );
@@ -77,23 +73,19 @@ contract AaveAssetManager is BaseAssetManager {
     uint256 liquidityMiddle_,
     uint256 liquidityMax_,
     uint256 claimRewardsMin_,
-    uint256 reinvestRewardsMin_,
-    uint256 maxSlippage_
+    uint256 reinvestRewardsMin_
   ) public initializer {
     __BaseAssetManager_init(liquidityMin_, liquidityMiddle_, liquidityMax_);
-    __AaveAssetManager_init(claimRewardsMin_, reinvestRewardsMin_, maxSlippage_);
+    __AaveAssetManager_init(claimRewardsMin_, reinvestRewardsMin_);
   }
 
   // solhint-disable-next-line func-name-mixedcase
-  function __AaveAssetManager_init(
-    uint256 claimRewardsMin_,
-    uint256 reinvestRewardsMin_,
-    uint256 maxSlippage_
-  ) internal initializer {
+  function __AaveAssetManager_init(uint256 claimRewardsMin_, uint256 reinvestRewardsMin_)
+    internal
+    initializer
+  {
     _claimRewardsMin = claimRewardsMin_;
     _reinvestRewardsMin = reinvestRewardsMin_;
-    require(maxSlippage_ <= 1e17, "maxSlippage can't be more than 10%");
-    _maxSlippage = maxSlippage_;
   }
 
   function getInvestmentValue() public view override returns (uint256) {
@@ -130,14 +122,14 @@ contract AaveAssetManager is BaseAssetManager {
     return ILendingPool(_aaveAddrProv.getLendingPool());
   }
 
-  function priceOracle() public view returns (IPriceOracle) {
-    return IPriceOracle(_aaveAddrProv.getPriceOracle());
-  }
-
   function _aaveDataProvider() internal view returns (AaveProtocolDataProvider) {
     return AaveProtocolDataProvider(_aaveAddrProv.getAddress(DATA_PROVIDER_ID));
   }
 
+  function _exchange() internal view returns (IExchange) {
+    return policyPool().config().exchange();
+  }
+
   function aToken() public view returns (IAToken) {
     return _aToken;
   }
@@ -158,19 +150,7 @@ contract AaveAssetManager is BaseAssetManager {
   }
 
   function _rewardToCurrency(uint256 amount) internal view returns (uint256) {
-    // TODO Check: this is safe? Or I should use IPriceOracle instead
-    IPriceOracle oracle = priceOracle();
-    IERC20Metadata from_ = rewardToken();
-    IERC20Metadata to_ = currency();
-    uint256 exchangeRate = oracle.getAssetPrice(address(from_)).wadDiv(
-      oracle.getAssetPrice(address(to_))
-    );
-    if (from_.decimals() > to_.decimals()) {
-      exchangeRate /= 10**(from_.decimals() - to_.decimals());
-    } else {
-      exchangeRate *= 10**(from_.decimals() - to_.decimals());
-    }
-    return amount.wadMul(exchangeRate);
+    return _exchange().convert(address(rewardToken()), address(currency()), amount);
   }
 
   function reinvestRewardToken() public {
@@ -183,28 +163,31 @@ contract AaveAssetManager is BaseAssetManager {
   }
 
   function _swapRewards(uint256 amount, address outAddr) internal returns (uint256, uint256) {
-    address[] memory path = _exchangePath();
-    uint256 swapIn = IERC20Metadata(path[0]).balanceOf(address(this));
+    IERC20Metadata rw = rewardToken();
+    uint256 swapIn = rw.balanceOf(address(this));
     if (swapIn < amount) {
       uint256 toWithdraw = amount - swapIn;
       if (rewardAToken().balanceOf(address(this)) < toWithdraw) {
         toWithdraw = type(uint256).max; // if not enought withdraw all
       }
-      swapIn += lendingPool().withdraw(path[0], toWithdraw, address(this));
+      swapIn += lendingPool().withdraw(address(rw), toWithdraw, address(this));
     } else {
       swapIn = amount;
     }
-    uint256 swapOutMin = _rewardToCurrency(swapIn).wadMul(1e18 - _maxSlippage);
-    IERC20Metadata(path[0]).approve(address(_swapRouter), swapIn);
-    uint256[] memory amounts = _swapRouter.swapExactTokensForTokens(
+    address swapRouter = _exchange().getSwapRouter();
+    rw.approve(swapRouter, swapIn);
+    bytes memory swapCall = _exchange().sell(
+      address(rw),
+      address(currency()),
       swapIn,
-      swapOutMin,
-      path,
       outAddr,
       block.timestamp
     );
-    emit RewardSwapped(swapIn, amounts[1]);
-    return (swapIn, amounts[1]);
+
+    bytes memory response = swapRouter.functionCall(swapCall, "Swap operation failed");
+    uint256 swapOut = _exchange().decodeSwapOut(response);
+    emit RewardSwapped(swapIn, swapOut);
+    return (swapIn, swapOut);
   }
 
   function swapRewards(uint256 amount)
@@ -250,7 +233,11 @@ contract AaveAssetManager is BaseAssetManager {
       // In this case, it's safe using getAmountsIn to compute how many rewards are needed to swap
       // but then, when I do the swap I validate the slippage with the market price (given by AAVE's Oracle)
       // is acceptable
-      uint256 requiredRewards = _swapRouter.getAmountsIn(remainingAmount, _exchangePath())[0];
+      uint256 requiredRewards = _exchange().getAmountIn(
+        address(rewardToken()),
+        address(currency()),
+        remainingAmount
+      );
       (, uint256 currencyOut) = _swapRewards(requiredRewards, address(_policyPool));
       if (currencyOut < remainingAmount) {
         remainingAmount -= currencyOut;
@@ -286,10 +273,6 @@ contract AaveAssetManager is BaseAssetManager {
     return _reinvestRewardsMin;
   }
 
-  function maxSlippage() external view returns (uint256) {
-    return _maxSlippage;
-  }
-
   function setClaimRewardsMin(uint256 newValue) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(
@@ -312,15 +295,4 @@ contract AaveAssetManager is BaseAssetManager {
     _reinvestRewardsMin = newValue;
     _parameterChanged(IPolicyPoolConfig.GovernanceActions.setReinvestRewardsMin, newValue, tweak);
   }
-
-  function setMaxSlippage(uint256 newValue) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
-    require(newValue <= 1e17, "maxSlippage can't be more than 10%");
-    bool tweak = !hasPoolRole(LEVEL2_ROLE);
-    require(
-      !tweak || _isTweakWad(_maxSlippage, newValue, 3e26),
-      "Tweak exceeded: maxSlippage tweaks only up to 30%"
-    );
-    _maxSlippage = newValue;
-    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setMaxSlippage, newValue, tweak);
-  }
 }

package/contracts/BaseAssetManager.sol

@@ -34,11 +34,6 @@ abstract contract BaseAssetManager is IAssetManager, PolicyPoolComponent {
   event MoneyDeinvested(uint256 amount);
   event EarningsDistributed(bool positive, uint256 amount);
 
-  modifier validateParamsAfterChange() {
-    _;
-    _validateParameters();
-  }
-
   /// @custom:oz-upgrades-unsafe-allow constructor
   // solhint-disable-next-line no-empty-blocks
   constructor(IPolicyPool policyPool_) PolicyPoolComponent(policyPool_) {}
@@ -74,7 +69,7 @@ abstract contract BaseAssetManager is IAssetManager, PolicyPoolComponent {
     _validateParameters();
   }
 
-  function _validateParameters() internal view {
+  function _validateParameters() internal view override {
     require(
       _liquidityMin <= _liquidityMiddle && _liquidityMiddle <= _liquidityMax,
       "Validation: Liquidity limits are invalid"
@@ -217,31 +212,7 @@ abstract contract BaseAssetManager is IAssetManager, PolicyPoolComponent {
     return _liquidityMax;
   }
 
-  function setLiquidityMin(uint256 newValue)
-    external
-    onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
-    validateParamsAfterChange
-  {
-    _setLiquidityMin(newValue);
-  }
-
-  function setLiquidityMiddle(uint256 newValue)
-    external
-    onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
-    validateParamsAfterChange
-  {
-    _setLiquidityMiddle(newValue);
-  }
-
-  function setLiquidityMax(uint256 newValue)
-    external
-    onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
-    validateParamsAfterChange
-  {
-    _setLiquidityMax(newValue);
-  }
-
-  function _setLiquidityMin(uint256 newValue) internal {
+  function setLiquidityMin(uint256 newValue) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(
       !tweak || _isTweakRay(_liquidityMin, newValue, 3e26),
@@ -251,7 +222,7 @@ abstract contract BaseAssetManager is IAssetManager, PolicyPoolComponent {
     _parameterChanged(IPolicyPoolConfig.GovernanceActions.setLiquidityMin, newValue, tweak);
   }
 
-  function _setLiquidityMiddle(uint256 newValue) internal {
+  function setLiquidityMiddle(uint256 newValue) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(
       !tweak || _isTweakRay(_liquidityMiddle, newValue, 3e26),
@@ -261,7 +232,7 @@ abstract contract BaseAssetManager is IAssetManager, PolicyPoolComponent {
     _parameterChanged(IPolicyPoolConfig.GovernanceActions.setLiquidityMiddle, newValue, tweak);
   }
 
-  function _setLiquidityMax(uint256 newValue) internal {
+  function setLiquidityMax(uint256 newValue) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(
       !tweak || _isTweakRay(_liquidityMax, newValue, 3e26),
@@ -275,9 +246,56 @@ abstract contract BaseAssetManager is IAssetManager, PolicyPoolComponent {
     uint256 min,
     uint256 middle,
     uint256 max
-  ) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) validateParamsAfterChange {
-    if (min != type(uint256).max) _setLiquidityMin(min);
-    if (middle != type(uint256).max) _setLiquidityMiddle(middle);
-    if (max != type(uint256).max) _setLiquidityMax(max);
+  ) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
+    bool setMin = min != type(uint256).max;
+    bool setMiddle = middle != type(uint256).max;
+    bool setMax = max != type(uint256).max;
+    bool tweak = !hasPoolRole(LEVEL2_ROLE);
+    // First set all - Then call _parameterChanged
+    if (setMin) {
+      require(
+        !tweak || _isTweakRay(_liquidityMin, min, 3e26),
+        "Tweak exceeded: liquidityMin tweaks only up to 30%"
+      );
+      _liquidityMin = min;
+    }
+    if (setMiddle) {
+      require(
+        !tweak || _isTweakRay(_liquidityMiddle, middle, 3e26),
+        "Tweak exceeded: liquidityMiddle tweaks only up to 30%"
+      );
+      _liquidityMiddle = middle;
+    }
+    if (setMax) {
+      require(
+        !tweak || _isTweakRay(_liquidityMax, max, 3e26),
+        "Tweak exceeded: liquidityMax tweaks only up to 30%"
+      );
+      _liquidityMax = max;
+    }
+    if (setMin) _parameterChanged(IPolicyPoolConfig.GovernanceActions.setLiquidityMin, min, tweak);
+    if (setMiddle)
+      _parameterChanged(IPolicyPoolConfig.GovernanceActions.setLiquidityMiddle, middle, tweak);
+    if (setMax) _parameterChanged(IPolicyPoolConfig.GovernanceActions.setLiquidityMax, max, tweak);
+  }
+
+  function _setLiquidityMiddle(uint256 newValue) internal {
+    bool tweak = !hasPoolRole(LEVEL2_ROLE);
+    require(
+      !tweak || _isTweakRay(_liquidityMiddle, newValue, 3e26),
+      "Tweak exceeded: liquidityMiddle tweaks only up to 30%"
+    );
+    _liquidityMiddle = newValue;
+    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setLiquidityMiddle, newValue, tweak);
+  }
+
+  function _setLiquidityMax(uint256 newValue) internal {
+    bool tweak = !hasPoolRole(LEVEL2_ROLE);
+    require(
+      !tweak || _isTweakRay(_liquidityMax, newValue, 3e26),
+      "Tweak exceeded: liquidityMax tweaks only up to 30%"
+    );
+    _liquidityMax = newValue;
+    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setLiquidityMax, newValue, tweak);
   }
 }

package/contracts/EToken.sol

@@ -64,11 +64,6 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
     _;
   }
 
-  modifier validateParamsAfterChange() {
-    _;
-    _validateParameters();
-  }
-
   /// @custom:oz-upgrades-unsafe-allow constructor
   // solhint-disable-next-line no-empty-blocks
   constructor(IPolicyPool policyPool_) PolicyPoolComponent(policyPool_) {}
@@ -130,7 +125,7 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
   }
 
   // runs validation on EToken parameters
-  function _validateParameters() internal view {
+  function _validateParameters() internal view override {
     require(
       _liquidityRequirement >= 8e26 && _liquidityRequirement <= 13e26,
       "Validation: liquidityRequirement must be [0.8, 1.3]"
@@ -703,7 +698,6 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
   function setPoolLoanInterestRate(uint256 newRate)
     external
     onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
-    validateParamsAfterChange
   {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(
@@ -718,7 +712,6 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
   function setLiquidityRequirement(uint256 newRate)
     external
     onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
-    validateParamsAfterChange
   {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(
@@ -729,11 +722,7 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
     _parameterChanged(IPolicyPoolConfig.GovernanceActions.setLiquidityRequirement, newRate, tweak);
   }
 
-  function setMaxUtilizationRate(uint256 newRate)
-    external
-    onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
-    validateParamsAfterChange
-  {
+  function setMaxUtilizationRate(uint256 newRate) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(
       !tweak || _isTweakRay(_maxUtilizationRate, newRate, 3e26),
@@ -743,11 +732,7 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
     _parameterChanged(IPolicyPoolConfig.GovernanceActions.setMaxUtilizationRate, newRate, tweak);
   }
 
-  function setAcceptAllRMs(bool acceptAllRMs_)
-    external
-    onlyPoolRole(LEVEL2_ROLE)
-    validateParamsAfterChange
-  {
+  function setAcceptAllRMs(bool acceptAllRMs_) external onlyPoolRole(LEVEL2_ROLE) {
     _acceptAllRMs = acceptAllRMs_;
     _parameterChanged(
       IPolicyPoolConfig.GovernanceActions.setAcceptAllRMs,
@@ -759,7 +744,6 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
   function setAcceptException(address riskModule, bool isException)
     external
     onlyPoolRole(LEVEL2_ROLE)
-    validateParamsAfterChange
   {
     _acceptExceptions[riskModule] = isException;
     uint256 value = uint160(riskModule);

package/contracts/Exchange.sol

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IUniswapV2Router02} from "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
+import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IPolicyPoolConfig} from "../interfaces/IPolicyPoolConfig.sol";
+import {PolicyPoolComponent} from "./PolicyPoolComponent.sol";
+import {IExchange, IPriceOracle} from "../interfaces/IExchange.sol";
+import {WadRayMath} from "./WadRayMath.sol";
+
+/**
+ * @title Exchange contract
+ * @dev Helper contract that handles exchange operations between assets
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+contract Exchange is IExchange, PolicyPoolComponent {
+  using WadRayMath for uint256;
+
+  IPriceOracle internal _oracle;
+  IUniswapV2Router02 internal _swapRouter; // We will use SushiSwap in Polygon
+  uint256 internal _maxSlippage; // Maximum slippage in WAD
+
+  /// @custom:oz-upgrades-unsafe-allow constructor
+  // solhint-disable-next-line no-empty-blocks
+  constructor(IPolicyPool policyPool_) PolicyPoolComponent(policyPool_) {}
+
+  /**
+   * @dev Initializes the RiskModule
+   * @param oracle_ Oracle that provides the price of the assets
+   * @param swapRouter_ Uniswap compatible exchange
+   * @param maxSlippage_ Maximum slippage admitted for exchange operations
+   */
+  function initialize(
+    IPriceOracle oracle_,
+    IUniswapV2Router02 swapRouter_,
+    uint256 maxSlippage_
+  ) public initializer {
+    __PolicyPoolComponent_init();
+    __Exchange_init(oracle_, swapRouter_, maxSlippage_);
+  }
+
+  // solhint-disable-next-line func-name-mixedcase
+  function __Exchange_init(
+    IPriceOracle oracle_,
+    IUniswapV2Router02 swapRouter_,
+    uint256 maxSlippage_
+  ) internal initializer {
+    _oracle = oracle_;
+    _swapRouter = swapRouter_;
+    _maxSlippage = maxSlippage_;
+    _validateParameters();
+  }
+
+  function _validateParameters() internal view override {
+    require(_maxSlippage <= 1e17, "maxSlippage can't be more than 10%");
+    require(address(_oracle) != address(0), "I need a price oracle");
+  }
+
+  function convert(
+    address assetFrom,
+    address assetTo,
+    uint256 amount
+  ) public view override returns (uint256) {
+    uint256 exchangeRate = _oracle.getAssetPrice(assetFrom).wadDiv(_oracle.getAssetPrice(assetTo));
+    uint8 decFrom = IERC20Metadata(assetFrom).decimals();
+    uint8 decTo = IERC20Metadata(assetTo).decimals();
+    if (decFrom > decTo) {
+      exchangeRate /= 10**(decFrom - decTo);
+    } else {
+      exchangeRate *= 10**(decTo - decFrom);
+    }
+    return amount.wadMul(exchangeRate);
+  }
+
+  function getAmountIn(
+    address assetIn,
+    address assetOut,
+    uint256 amountOut
+  ) external view override returns (uint256) {
+    return _swapRouter.getAmountsIn(amountOut, _exchangePath(assetIn, assetOut))[0];
+  }
+
+  function getSwapRouter() external view override returns (address) {
+    return address(_swapRouter);
+  }
+
+  function getPriceOracle() external view override returns (IPriceOracle) {
+    return IPriceOracle(_oracle);
+  }
+
+  function _exchangePath(address assetIn, address assetOut)
+    internal
+    pure
+    returns (address[] memory)
+  {
+    address[] memory path = new address[](2);
+    path[0] = assetIn;
+    path[1] = assetOut;
+    return path;
+  }
+
+  function sell(
+    address assetIn,
+    address assetOut,
+    uint256 amountInExact,
+    address outAddr,
+    uint256 deadline
+  ) external view override returns (bytes memory) {
+    uint256 amountOutMin = convert(assetIn, assetOut, amountInExact).wadMul(1e18 - _maxSlippage);
+
+    return
+      abi.encodeWithSignature(
+        "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)",
+        amountInExact,
+        amountOutMin,
+        _exchangePath(assetIn, assetOut),
+        outAddr,
+        deadline
+      );
+  }
+
+  function decodeSwapOut(bytes memory responseData) external pure override returns (uint256) {
+    return abi.decode(responseData, (uint256[]))[1];
+  }
+
+  function maxSlippage() external view returns (uint256) {
+    return _maxSlippage;
+  }
+
+  function setMaxSlippage(uint256 newValue) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
+    require(newValue <= 1e17, "maxSlippage can't be more than 10%");
+    bool tweak = !hasPoolRole(LEVEL2_ROLE);
+    require(
+      !tweak || _isTweakWad(_maxSlippage, newValue, 3e26),
+      "Tweak exceeded: maxSlippage tweaks only up to 30%"
+    );
+    _maxSlippage = newValue;
+    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setMaxSlippage, newValue, tweak);
+  }
+}