@ensuro/core 2.0.1 → 2.1.0-beta2

package/contracts/EToken.sol

@@ -220,6 +220,36 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     return _tsScaled.getScale(tokenInterestRate()).rayMul(principalBalance.wadToRay()).rayToWad();
   }
 
+  // Methods following AAVE's IScaledBalanceToken, to simplify future integrations
+
+  /**
+   * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the
+   * updated stored balance divided by the EToken's scale index
+   * @param user The user whose balance is calculated
+   * @return The scaled balance of the user
+   **/
+  function scaledBalanceOf(address user) external view returns (uint256) {
+    return _balances[user];
+  }
+
+  /**
+   * @dev Returns the scaled balance of the user and the scaled total supply.
+   * @param user The address of the user
+   * @return The scaled balance of the user
+   * @return The scaled balance and the scaled total supply
+   **/
+  function getScaledUserBalanceAndSupply(address user) external view returns (uint256, uint256) {
+    return (_balances[user], uint256(_tsScaled.amount));
+  }
+
+  /**
+   * @dev Returns the (un)scaled total supply of the EToken. Equals to the sum of `scaledBalanceOf(x)` of all users
+   * @return The scaled total supply
+   **/
+  function scaledTotalSupply() external view returns (uint256) {
+    return uint256(_tsScaled.amount);
+  }
+
   /**
    * @dev See {IERC20-transfer}.
    *
@@ -481,10 +511,14 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     uint256 totalSupply_ = this.totalSupply();
     if (totalSupply_ == 0) _scr.tokenInterestRate = 0;
     else {
-      _scr.tokenInterestRate = uint256(_scr.interestRate)
-        .wadMul(uint256(_scr.scr))
-        .wadDiv(totalSupply_)
-        .toUint64();
+      uint256 newTokenInterestRate = uint256(_scr.interestRate).wadMul(uint256(_scr.scr)).wadDiv(
+        totalSupply_
+      );
+      _scr.tokenInterestRate = (newTokenInterestRate > type(uint64).max)
+        ? type(uint64).max
+        : newTokenInterestRate.toUint64();
+      // This is not the mathematically correct value, but the max we can set. The actual value of the total supply
+      // will be adjusted when the policies expire or are resolved and the SCR is unlocked.
     }
   }
 
@@ -500,9 +534,8 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
   }
 
   function fundsAvailableToLock() public view returns (uint256) {
-    uint256 totalSupply_ = this.totalSupply();
-    if (totalSupply_ > uint256(_scr.scr))
-      return (totalSupply_ - uint256(_scr.scr)).wadMul(maxUtilizationRate());
+    uint256 supply = this.totalSupply().wadMul(maxUtilizationRate());
+    if (supply > uint256(_scr.scr)) return supply - uint256(_scr.scr);
     else return 0;
   }
 
@@ -645,8 +678,15 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
      * The only limit for withdraws is the `totalWithdrawable()` function, that's affected by the relation between the
      * scr and the totalSupply.
      */
-    amount = Math.min(amount, Math.min(balanceOf(provider), totalWithdrawable()));
+    uint256 maxWithdraw = Math.min(balanceOf(provider), totalWithdrawable());
+    if (amount == type(uint256).max) amount = maxWithdraw;
     if (amount == 0) return 0;
+    require(amount <= maxWithdraw, "amount > max withdrawable");
+    require(
+      address(_params.whitelist) == address(0) ||
+        _params.whitelist.acceptsWithdrawal(this, provider, amount),
+      "Liquidity Provider not whitelisted"
+    );
     _burn(provider, amount);
     _updateTokenInterestRate();
     _transferTo(provider, amount);
@@ -669,16 +709,23 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     emit InternalBorrowerRemoved(borrower, defaultedDebt);
   }
 
-  function internalLoan(
-    uint256 amount,
-    address receiver,
-    bool fromAvailable
-  ) external override onlyBorrower whenNotPaused returns (uint256) {
+  /**
+   * @dev Returns the maximum negative adjustment (discrete loss) the eToken can accept without breaking consistency.
+   *      The limit comes from limits in the internal scale that takes scaledTotalSupply() to totalSupply()
+   */
+  function maxNegativeAdjustment() public view returns (uint256) {
+    return totalSupply() - _tsScaled.minValue(); // Min value accepted by _tsScaled
+  }
+
+  function internalLoan(uint256 amount, address receiver)
+    external
+    override
+    onlyBorrower
+    whenNotPaused
+    returns (uint256)
+  {
     uint256 amountAsked = amount;
-    amount = Math.min(
-      Math.min(amount, fromAvailable ? fundsAvailable() : totalSupply()),
-      _tsScaled.maxNegativeAdjustment(tokenInterestRate())
-    );
+    amount = Math.min(amount, maxNegativeAdjustment());
     if (amount == 0) return amountAsked;
     TimeScaled.ScaledAmount storage loan = _loans[_msgSender()];
     loan.add(amount, internalLoanInterestRate());

package/contracts/LPManualWhitelist.sol

@@ -14,10 +14,27 @@ import {IEToken} from "./interfaces/IEToken.sol";
  */
 contract LPManualWhitelist is ILPWhitelist, PolicyPoolComponent {
   bytes32 public constant LP_WHITELIST_ROLE = keccak256("LP_WHITELIST_ROLE");
+  bytes32 public constant LP_WHITELIST_ADMIN_ROLE = keccak256("LP_WHITELIST_ADMIN_ROLE");
 
-  mapping(address => bool) private _whitelisted;
+  /**
+   * @dev Enum with the different options for whitelisting status
+   */
+  enum WhitelistOptions {
+    undefined,
+    whitelisted,
+    blacklisted
+  }
+
+  struct WhitelistStatus {
+    WhitelistOptions deposit;
+    WhitelistOptions withdraw;
+    WhitelistOptions sendTransfer;
+    WhitelistOptions receiveTransfer;
+  }
 
-  event LPWhitelisted(address provider, bool whitelisted);
+  mapping(address => WhitelistStatus) private _wlStatus;
+
+  event LPWhitelistStatusChanged(address provider, WhitelistStatus whitelisted);
 
   /// @custom:oz-upgrades-unsafe-allow constructor
   // solhint-disable-next-line no-empty-blocks
@@ -26,18 +43,62 @@ contract LPManualWhitelist is ILPWhitelist, PolicyPoolComponent {
   /**
    * @dev Initializes the Whitelist contract
    */
-  function initialize() public initializer {
+  function initialize(WhitelistStatus calldata defaultStatus) public virtual initializer {
+    __LPManualWhitelist_init(defaultStatus);
+  }
+
+  // solhint-disable-next-line func-name-mixedcase
+  function __LPManualWhitelist_init(WhitelistStatus calldata defaultStatus)
+    internal
+    onlyInitializing
+  {
     __PolicyPoolComponent_init();
+    __LPManualWhitelist_init_unchained(defaultStatus);
   }
 
-  function whitelistAddress(address provider, bool whitelisted)
+  // solhint-disable-next-line func-name-mixedcase
+  function __LPManualWhitelist_init_unchained(WhitelistStatus calldata defaultStatus)
+    internal
+    onlyInitializing
+  {
+    _checkDefaultStatus(defaultStatus);
+    _wlStatus[address(0)] = defaultStatus;
+    emit LPWhitelistStatusChanged(address(0), defaultStatus);
+  }
+
+  function whitelistAddress(address provider, WhitelistStatus calldata newStatus)
     external
     onlyComponentRole(LP_WHITELIST_ROLE)
   {
-    if (_whitelisted[provider] != whitelisted) {
-      _whitelisted[provider] = whitelisted;
-      emit LPWhitelisted(provider, whitelisted);
-    }
+    require(provider != address(0), "You can't change the defaults");
+    _whitelistAddress(provider, newStatus);
+  }
+
+  function _checkDefaultStatus(WhitelistStatus calldata newStatus) internal pure {
+    require(
+      newStatus.deposit != WhitelistOptions.undefined &&
+        newStatus.withdraw != WhitelistOptions.undefined &&
+        newStatus.sendTransfer != WhitelistOptions.undefined &&
+        newStatus.receiveTransfer != WhitelistOptions.undefined,
+      "You need to define the default status for all the operations"
+    );
+  }
+
+  function setWhitelistDefaults(WhitelistStatus calldata newStatus)
+    external
+    onlyComponentRole(LP_WHITELIST_ADMIN_ROLE)
+  {
+    _checkDefaultStatus(newStatus);
+    _whitelistAddress(address(0), newStatus);
+  }
+
+  function getWhitelistDefaults() external view returns (WhitelistStatus memory) {
+    return _wlStatus[address(0)];
+  }
+
+  function _whitelistAddress(address provider, WhitelistStatus memory newStatus) internal {
+    _wlStatus[provider] = newStatus;
+    emit LPWhitelistStatusChanged(provider, newStatus);
   }
 
   /**
@@ -52,16 +113,41 @@ contract LPManualWhitelist is ILPWhitelist, PolicyPoolComponent {
     address provider,
     uint256
   ) external view override returns (bool) {
-    return _whitelisted[provider];
+    WhitelistOptions wl = _wlStatus[provider].deposit;
+    if (wl == WhitelistOptions.undefined) {
+      wl = _wlStatus[address(0)].deposit;
+    }
+    return wl == WhitelistOptions.whitelisted;
+  }
+
+  function acceptsWithdrawal(
+    IEToken,
+    address provider,
+    uint256
+  ) external view override returns (bool) {
+    WhitelistOptions wl = _wlStatus[provider].withdraw;
+    if (wl == WhitelistOptions.undefined) {
+      wl = _wlStatus[address(0)].withdraw;
+    }
+    return wl == WhitelistOptions.whitelisted;
   }
 
   function acceptsTransfer(
     IEToken,
-    address,
+    address providerFrom,
     address providerTo,
     uint256
   ) external view override returns (bool) {
-    return _whitelisted[providerTo];
+    WhitelistOptions wl = _wlStatus[providerFrom].sendTransfer;
+    if (wl == WhitelistOptions.undefined) {
+      wl = _wlStatus[address(0)].sendTransfer;
+    }
+    if (wl != WhitelistOptions.whitelisted) return false;
+    wl = _wlStatus[providerTo].receiveTransfer;
+    if (wl == WhitelistOptions.undefined) {
+      wl = _wlStatus[address(0)].receiveTransfer;
+    }
+    return wl == WhitelistOptions.whitelisted;
   }
 
   /**

package/contracts/PremiumsAccount.sol

@@ -65,9 +65,20 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
    */
   int256 internal _surplus;
 
+  /**
+   * @dev This struct has the parameters that can be modified by governance
+   * @member deficitRatio A value between [0, 1] that defines the percentage of active pure premiums that can be used
+   *                      to cover losses.
+   * @member assetManager This is the implementation contract that manages the PremiumsAccount's funds. See
+   *                      {IAssetManager}
+   * @member jrLoanLimit  This is the maximum amount that can be borrowed from the Junior eToken (without decimals)
+   * @member srLoanLimit  This is the maximum amount that can be borrowed from the Senior eToken (without decimals)
+   */
   struct PackedParams {
     uint16 deficitRatio;
     IAssetManager assetManager;
+    uint32 jrLoanLimit;
+    uint32 srLoanLimit;
   }
 
   PackedParams internal _params;
@@ -120,7 +131,9 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     */
     _params = PackedParams({
       deficitRatio: HUNDRED_PERCENT,
-      assetManager: IAssetManager(address(0))
+      assetManager: IAssetManager(address(0)),
+      jrLoanLimit: 0,
+      srLoanLimit: 0
     });
     _validateParameters();
   }
@@ -240,6 +253,16 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     return -int256(_activePurePremiums.wadMul(ratio));
   }
 
+  function _toAmount(uint32 value) internal view returns (uint256) {
+    // 0 decimals to amount decimals
+    return uint256(value) * 10**currency().decimals();
+  }
+
+  function _toZeroDecimals(uint256 amount) internal view returns (uint32) {
+    // Removes the decimals from the amount
+    return (amount / 10**currency().decimals()).toUint32();
+  }
+
   /**
    * @dev Returns the percentage of the active pure premiums that can be used to cover losses of finalized policies.
    */
@@ -247,6 +270,20 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     return uint256(_params.deficitRatio) * FOUR_DECIMAL_TO_WAD; // 4 -> 18 decimals
   }
 
+  /**
+   * @dev Returns the limit on the Junior eToken loans (infinite if _params.jrLoanLimit == 0)
+   */
+  function jrLoanLimit() public view returns (uint256) {
+    return _params.jrLoanLimit == 0 ? type(uint256).max : _toAmount(_params.jrLoanLimit);
+  }
+
+  /**
+   * @dev Returns the limit on the Senior eToken loans (infinite if _params.srLoanLimit == 0)
+   */
+  function srLoanLimit() public view returns (uint256) {
+    return _params.srLoanLimit == 0 ? type(uint256).max : _toAmount(_params.srLoanLimit);
+  }
+
   /**
    * @dev Changes the `deficitRatio` parameter.
    *
@@ -262,7 +299,7 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
    */
   function setDeficitRatio(uint256 newRatio, bool adjustment)
     external
-    onlyComponentRole(LEVEL2_ROLE)
+    onlyGlobalOrComponentRole(LEVEL2_ROLE)
   {
     require(newRatio <= 1e18, "Validation: deficitRatio must be <= 1");
 
@@ -287,6 +324,36 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     _parameterChanged(action, newRatio, false);
   }
 
+  /**
+   * @dev Changes the `jrLoanLimit` or `srLoanLimit` parameter.
+   *
+   * Requirements:
+   * - onlyGlobalOrComponentRole(LEVEL2_ROLE)
+   *
+   * Events:
+   * - Emits GovernanceAction with action = setDeficitRatio or setDeficitRatioWithAdjustment if an adjustment was made.
+   *
+   * @param newLimitJr     The new limit to be set for the loans taken from the Junior eToken.
+                           If newLimitJr == MAX_UINT, it's ignored. If == 0, means the loans are unbounded.
+   * @param newLimitSr     The new limit to be set for the loans taken from the Senior eToken.
+                           If newLimitSr == MAX_UINT, it's ignored. If == 0, means the loans are unbounded.
+   */
+  function setLoanLimits(uint256 newLimitJr, uint256 newLimitSr)
+    external
+    onlyGlobalOrComponentRole(LEVEL2_ROLE)
+  {
+    if (newLimitJr != type(uint256).max) {
+      _params.jrLoanLimit = _toZeroDecimals(newLimitJr);
+      require(_toAmount(_params.jrLoanLimit) == newLimitJr, "Validation: no decimals allowed");
+      _parameterChanged(IAccessManager.GovernanceActions.setJrLoanLimit, newLimitJr, false);
+    }
+    if (newLimitSr != type(uint256).max) {
+      _params.srLoanLimit = _toZeroDecimals(newLimitSr);
+      require(_toAmount(_params.srLoanLimit) == newLimitSr, "Validation: no decimals allowed");
+      _parameterChanged(IAccessManager.GovernanceActions.setSrLoanLimit, newLimitSr, false);
+    }
+  }
+
   /**
    * @dev Internal function called when money in the PremiumsAccount is not enough and we need to borrow from the
    * eTokens.
@@ -302,17 +369,22 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     bool jrEtk
   ) internal {
     require(receiver != address(0), "PremiumsAccount: receiver cannot be the zero address");
-    uint256 left;
+    uint256 left = borrow;
     if (jrEtk) {
-      // Consume Junior Pool until exhausted
-      left = _juniorEtk.internalLoan(borrow, receiver, false);
-    } else {
-      left = borrow;
+      if (_juniorEtk.getLoan(address(this)) + borrow <= jrLoanLimit()) {
+        left = _juniorEtk.internalLoan(borrow, receiver);
+      } else if (_juniorEtk.getLoan(address(this)) < jrLoanLimit()) {
+        // Partial loan
+        uint256 loanExcess = _juniorEtk.getLoan(address(this)) + borrow - jrLoanLimit();
+        left = loanExcess + _juniorEtk.internalLoan(borrow - loanExcess, receiver);
+      }
     }
     if (left > NEGLIGIBLE_AMOUNT) {
       // Consume Senior Pool only up to SCR
-      left = _seniorEtk.internalLoan(left, receiver, true);
-      require(left <= NEGLIGIBLE_AMOUNT, "Don't know where to take the rest of the money");
+      if (_seniorEtk.getLoan(address(this)) + left < srLoanLimit()) {
+        left = _seniorEtk.internalLoan(left, receiver);
+      } // in the senior eToken doesn't make sense to handle partial loan
+      require(left <= NEGLIGIBLE_AMOUNT, "Don't know where to source the rest of the money");
     }
   }
 
@@ -360,9 +432,16 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
    * @param amount The amount to be transferred.
    */
   function receiveGrant(uint256 amount) external {
-    _storePurePremiumWon(amount);
-    emit WonPremiumsInOut(true, amount);
+    // I need to receive the money first (without following the Check-Effects-Interactions) pattern because I need
+    // the money to pay the eTokens
     currency().safeTransferFrom(_msgSender(), address(this), amount);
+    uint256 purePremiumWon = amount;
+    if (address(_seniorEtk) != address(0)) purePremiumWon = _repayLoan(purePremiumWon, _seniorEtk);
+    if (address(_juniorEtk) != address(0)) purePremiumWon = _repayLoan(purePremiumWon, _juniorEtk);
+
+    // Finally store purePremiumWon
+    _storePurePremiumWon(purePremiumWon);
+    emit WonPremiumsInOut(true, amount);
   }
 
   /**

package/contracts/RiskModule.sol

@@ -185,12 +185,12 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
 
   // solhint-disable-next-line func-name-mixedcase
   function _XtoAmount(uint8 decimals, uint32 value) internal view returns (uint256) {
-    // X decimals to Wad (18 decimals)
+    // X decimals to currency decimals (6 for USDC)
     return uint256(value) * 10**(currency().decimals() - decimals);
   }
 
   function _amountToX(uint8 decimals, uint256 value) internal view returns (uint32) {
-    // Wad to X decimals
+    // currency decimals to X decimals (assuming X < currency decimals)
     return (value / 10**(currency().decimals() - decimals)).toUint32();
   }
 

package/contracts/TimeScaled.sol

@@ -125,14 +125,7 @@ library TimeScaled {
     require(scaledAmount.scale >= MIN_SCALE, "Scale too small, can lead to rounding errors");
   }
 
-  function maxNegativeAdjustment(ScaledAmount storage scaledAmount, uint256 interestRate)
-    internal
-    view
-    returns (uint256)
-  {
-    uint256 ts = getScaledAmount(scaledAmount, interestRate);
-    uint256 minTs = uint256(scaledAmount.amount).wadToRay().rayMul(MIN_SCALE).rayToWad();
-    if (ts > minTs) return ts - minTs;
-    else return 0;
+  function minValue(ScaledAmount storage scaledAmount) internal view returns (uint256) {
+    return uint256(scaledAmount.amount).wadToRay().rayMul(MIN_SCALE).rayToWad();
   }
 }

package/contracts/interfaces/IAccessManager.sol

@@ -52,10 +52,10 @@ interface IAccessManager is IAccessControlUpgradeable {
     // PremiumsAccount Governance Actions
     setDeficitRatio,
     setDeficitRatioWithAdjustment,
-    paFiller1,
-    paFiller2,
-    paFiller3,
-    paFiller4,
+    setJrLoanLimit,
+    setSrLoanLimit,
+    paFiller3, // Reserve space for future PremiumsAccount actions
+    paFiller4, // Reserve space for future PremiumsAccount actions
     // AssetManager Governance Actions
     setLiquidityMin,
     setLiquidityMiddle,

package/contracts/interfaces/IEToken.sol

@@ -152,15 +152,9 @@ interface IEToken is IERC20 {
    *
    * @param amount The amount required
    * @param receiver The received of the funds lent. This is usually the policyholder if the loan is used for a payout.
-   * @param fromAvailable If `true`, the funds that can be lent are only the available ones, i.e., excluding the funds
-   * locked as `scr()`. If `false`, all the `totalSupply()` is available to be lent.
    * @return Returns the amount that wasn't able to fulfil. `amount - lent`
    */
-  function internalLoan(
-    uint256 amount,
-    address receiver,
-    bool fromAvailable
-  ) external returns (uint256);
+  function internalLoan(uint256 amount, address receiver) external returns (uint256);
 
   /**
    * @dev Repays a loan taken with `internalLoan`.

package/contracts/interfaces/ILPWhitelist.sol

@@ -37,4 +37,18 @@ interface ILPWhitelist {
     address providerTo,
     uint256 amount
   ) external view returns (bool);
+
+  /**
+   * @dev Indicates whether or not a liquidity provider can withdraw an eToken.
+   *
+   * @param etoken The eToken (see {EToken}) where the provider wants to withdraw money.
+   * @param provider The address of the liquidity provider (user) that wants to withdraw
+   * @param amount The amount of the withdrawal
+   * @return true if `provider` withdraw request is accepted, false if not
+   */
+  function acceptsWithdrawal(
+    IEToken etoken,
+    address provider,
+    uint256 amount
+  ) external view returns (bool);
 }

package/js/deploy.js

@@ -7,6 +7,12 @@ const _BN = ethers.BigNumber.from;
 const WAD = _BN(1e10).mul(_BN(1e8)); // 1e10*1e8=1e18
 const RAY = WAD.mul(_BN(1e9)); // 1e18*1e9=1e27
 
+const WhitelistStatus = {
+  notdefined: 0,
+  whitelisted: 1,
+  blacklisted: 2,
+};
+
 /**
  * Creates a fixed-point conversion function for the desired number of decimals
  * @param decimals The number of decimals. Must be >= 6.
@@ -153,10 +159,8 @@ async function deployProxyContract({ saveAddr, verify, contractClass, constructo
 }
 
 function parseRole(role) {
-  if (role.startsWith("0x"))
-    return role;
-  if (role === "DEFAULT_ADMIN_ROLE")
-    return ethers.constants.HashZero;
+  if (role.startsWith("0x")) return role;
+  if (role === "DEFAULT_ADMIN_ROLE") return ethers.constants.HashZero;
   return ethers.utils.keccak256(ethers.utils.toUtf8Bytes(role));
 }
 
@@ -255,8 +259,7 @@ async function deployEToken(
     hre
   );
   const policyPool = await hre.ethers.getContractAt("PolicyPool", poolAddress);
-  if (opts.addComponent)
-    await policyPool.addComponent(contract.address, 1);
+  if (opts.addComponent) await policyPool.addComponent(contract.address, 1);
   return contract.address;
 }
 
@@ -271,8 +274,7 @@ async function deployPremiumsAccount({ poolAddress, juniorEtk, seniorEtk, ...opt
     hre
   );
   const policyPool = await hre.ethers.getContractAt("PolicyPool", poolAddress);
-  if (opts.addComponent)
-    await policyPool.addComponent(contract.address, 3);
+  if (opts.addComponent) await policyPool.addComponent(contract.address, 3);
   return contract.address;
 }
 
@@ -338,11 +340,10 @@ async function deployRiskModule(
     await rm.setParam(4, ensuroCocFee);
   }
   if (maxDuration != 24 * 365) {
-    await rm.setParam(9, ensuroCocFee);
+    await rm.setParam(9, maxDuration);
   }
   const policyPool = await hre.ethers.getContractAt("PolicyPool", poolAddress);
-  if (opts.addComponent)
-    await policyPool.addComponent(contract.address, 2);
+  if (opts.addComponent) await policyPool.addComponent(contract.address, 2);
   return contract.address;
 }
 
@@ -415,10 +416,16 @@ async function deployAaveAssetManager({ asset, aave, amClass, ...opts }, hre) {
 }
 
 async function deployWhitelist(
-  { wlClass, poolAddress, extraConstructorArgs, extraArgs, eToken, eToken2, eToken3, ...opts },
+  { wlClass, poolAddress, extraConstructorArgs, extraArgs, eToken, eToken2, eToken3, defaultStatus, ...opts },
   hre
 ) {
   extraArgs = extraArgs || [];
+  if (defaultStatus !== "") {
+    defaultStatus = defaultStatus
+      .split("")
+      .map((WB) => (WB == "W" ? WhitelistStatus.whitelisted : WhitelistStatus.blacklisted));
+    extraArgs.splice(0, 0, defaultStatus);
+  }
   extraConstructorArgs = extraConstructorArgs || [];
   const { contract } = await deployProxyContract(
     {
@@ -706,6 +713,7 @@ function add_task() {
     .addOptionalParam("eToken", "Set the Whitelist to a given eToken", undefined, types.address)
     .addOptionalParam("eToken2", "Set the Whitelist to a given eToken", undefined, types.address)
     .addOptionalParam("eToken3", "Set the Whitelist to a given eToken", undefined, types.address)
+    .addOptionalParam("defaultStatus", "Default Status Ej: 'BWWB'", "BWWB", types.str)
     .addParam("poolAddress", "PolicyPool Address", types.address)
     .setAction(deployWhitelist);
 
@@ -776,4 +784,5 @@ module.exports = {
   deploySignedQuoteRM,
   setAssetManager,
   deployWhitelist,
+  WhitelistStatus,
 };

package/js/test-utils.js

@@ -414,8 +414,8 @@ function makePolicyId(rm, internalId) {
 
 exports.makePolicyId = makePolicyId;
 
-async function makePolicy(pool, rm, cust, payout, premium, lossProb, expiration, internalId) {
-  let tx = await rm.connect(cust).newPolicy(payout, premium, lossProb, expiration, cust.address, internalId);
+async function makePolicy(pool, rm, cust, payout, premium, lossProb, expiration, internalId, method = "newPolicy") {
+  let tx = await rm.connect(cust)[method](payout, premium, lossProb, expiration, cust.address, internalId);
   let receipt = await tx.wait();
   const newPolicyEvt = getTransactionEvent(pool.interface, receipt, "NewPolicy");
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ensuro/core",
   "description": "Ensuro - Decentralized insurance protocol",
-  "version": "2.0.1",
+  "version": "2.1.0-beta2",
   "files": [
     "**/*.sol",
     "/build/contracts/*.json",