@ensuro/core 2.2.1 → 2.4.0

package/contracts/PremiumsAccount.sol

@@ -35,6 +35,7 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
   using SafeCast for uint256;
 
   bytes32 public constant WITHDRAW_WON_PREMIUMS_ROLE = keccak256("WITHDRAW_WON_PREMIUMS_ROLE");
+  bytes32 public constant REPAY_LOANS_ROLE = keccak256("REPAY_LOANS_ROLE");
   uint256 internal constant FOUR_DECIMAL_TO_WAD = 1e14;
   uint16 internal constant HUNDRED_PERCENT = 1e4;
 
@@ -92,6 +93,19 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
    */
   event WonPremiumsInOut(bool moneyIn, uint256 value);
 
+  /**
+   * @dev Modifier to make a function callable only by a certain global or component role.
+   * In addition to checking the sender's role, `address(0)` 's role is also
+   * considered. Granting a role to `address(0)` (at global or component level) is equivalent
+   * to enabling this role for everyone.
+   */
+  modifier onlyGlobalOrComponentOrOpenRole(bytes32 role) {
+    if (!_policyPool.access().hasComponentRole(address(this), role, address(0), true)) {
+      _policyPool.access().checkComponentRole(address(this), role, _msgSender(), true);
+    }
+    _;
+  }
+
   /**
    * @dev Constructor of the contract, sets the immutable fields.
    *
@@ -176,13 +190,10 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
    *   loans to cover asset losses.
    */
   function _assetEarnings(int256 earningsOrLosses) internal override {
-    if (earningsOrLosses > 0) {
-      uint256 earnings = uint256(earningsOrLosses);
-      if (address(_seniorEtk) != address(0)) earnings = _repayLoan(earnings, _seniorEtk);
-      if (address(_juniorEtk) != address(0)) earnings = _repayLoan(earnings, _juniorEtk);
-      _storePurePremiumWon(earnings);
+    if (earningsOrLosses >= 0) {
+      _storePurePremiumWon(uint256(earningsOrLosses));
     } else {
-      require(_payFromPremiums(uint256(-earningsOrLosses)) == 0, "Losses can't exceed maxDeficit");
+      require(_payFromPremiums(-earningsOrLosses) == 0, "Losses can't exceed maxDeficit");
     }
   }
 
@@ -230,6 +241,14 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     return _surplus;
   }
 
+  /**
+   * @dev Returns the amount of funds available to cover losses or repay eToken loans.
+   */
+  function fundsAvailable() public view returns (uint256) {
+    // This is guaranteed to be positive because _maxDeficit is negative and always gte _surplus in absolute value
+    return uint256(_surplus - _maxDeficit(deficitRatio()));
+  }
+
   function seniorEtk() external view override returns (IEToken) {
     return _seniorEtk;
   }
@@ -301,8 +320,6 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     external
     onlyGlobalOrComponentRole(LEVEL2_ROLE)
   {
-    require(newRatio <= 1e18, "Validation: deficitRatio must be <= 1");
-
     uint16 truncatedRatio = (newRatio / FOUR_DECIMAL_TO_WAD).toUint16();
     require(
       uint256(truncatedRatio) * FOUR_DECIMAL_TO_WAD == newRatio,
@@ -311,6 +328,8 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
 
     int256 maxDeficit = _maxDeficit(newRatio);
     require(adjustment || _surplus >= maxDeficit, "Validation: surplus must be >= maxDeficit");
+    _params.deficitRatio = truncatedRatio;
+    _validateParameters();
 
     IAccessManager.GovernanceActions action = IAccessManager.GovernanceActions.setDeficitRatio;
     if (_surplus < maxDeficit) {
@@ -320,7 +339,6 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
       _borrowFromEtk(borrow, address(this), address(_juniorEtk) != address(0));
       action = IAccessManager.GovernanceActions.setDeficitRatioWithAdjustment;
     }
-    _params.deficitRatio = truncatedRatio;
     _parameterChanged(action, newRatio, false);
   }
 
@@ -368,7 +386,6 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     address receiver,
     bool jrEtk
   ) internal {
-    require(receiver != address(0), "PremiumsAccount: receiver cannot be the zero address");
     uint256 left = borrow;
     if (jrEtk) {
       if (_juniorEtk.getLoan(address(this)) + borrow <= jrLoanLimit()) {
@@ -395,8 +412,8 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
    * @param toPay The amount to pay.
    * @return The amount that couldn't be paid from the premiums account.
    */
-  function _payFromPremiums(uint256 toPay) internal returns (uint256) {
-    int256 newSurplus = _surplus - int256(toPay);
+  function _payFromPremiums(int256 toPay) internal returns (uint256) {
+    int256 newSurplus = _surplus - toPay;
     int256 maxDeficit = _maxDeficit(deficitRatio());
     if (newSurplus >= maxDeficit) {
       _surplus = newSurplus;
@@ -413,7 +430,6 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
    * @param purePremiumWon The amount earned
    */
   function _storePurePremiumWon(uint256 purePremiumWon) internal {
-    if (purePremiumWon == 0) return;
     _surplus += int256(purePremiumWon);
   }
 
@@ -432,15 +448,8 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
    * @param amount The amount to be transferred.
    */
   function receiveGrant(uint256 amount) external {
-    // I need to receive the money first (without following the Check-Effects-Interactions) pattern because I need
-    // the money to pay the eTokens
+    _storePurePremiumWon(amount);
     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);
   }
 
@@ -497,23 +506,14 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     uint256 payout
   ) external override onlyPolicyPool whenNotPaused {
     _activePurePremiums -= policy.purePremium;
-    if (policy.purePremium >= payout) {
-      uint256 purePremiumWon = policy.purePremium - payout;
-      if (address(_seniorEtk) != address(0))
-        purePremiumWon = _repayLoan(purePremiumWon, _seniorEtk);
-      if (address(_juniorEtk) != address(0))
-        purePremiumWon = _repayLoan(purePremiumWon, _juniorEtk);
-      _storePurePremiumWon(purePremiumWon);
+    uint256 borrowFromScr = _payFromPremiums(int256(payout) - int256(policy.purePremium));
+    if (borrowFromScr != 0) {
       _unlockScr(policy);
-      _transferTo(policyHolder, payout);
+      _borrowFromEtk(borrowFromScr, policyHolder, policy.jrScr > 0);
     } else {
-      uint256 borrowFromScr = _payFromPremiums(payout - policy.purePremium);
       _unlockScr(policy);
-      if (borrowFromScr > 0) {
-        _borrowFromEtk(borrowFromScr, policyHolder, policy.jrScr > 0);
-      }
-      _transferTo(policyHolder, payout - borrowFromScr);
     }
+    _transferTo(policyHolder, payout - borrowFromScr);
   }
 
   /**
@@ -538,18 +538,37 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     }
   }
 
+  /**
+   * @dev Function that repays the loan(s) if fundsAvailable
+   *
+   * @return available The funds still available after repayment
+   */
+  function repayLoans()
+    external
+    onlyGlobalOrComponentOrOpenRole(REPAY_LOANS_ROLE)
+    whenNotPaused
+    returns (uint256 available)
+  {
+    available = fundsAvailable();
+    if (available != 0 && address(_seniorEtk) != address(0))
+      available = _repayLoan(available, _seniorEtk);
+    if (available != 0 && address(_juniorEtk) != address(0))
+      available = _repayLoan(available, _juniorEtk);
+    return available;
+  }
+
   /**
    * @dev Internal function that repays a loan taken (if any outstanding) from the an eToken
    *
-   * @param purePremiumWon The amount earned and available for loan repayment.
+   * @param fundsAvailable_ The amount of funds available for the repayment
    * @param etk The eToken with the potential debt
    * @return The excess amount of the purePremiumWon that wasn't used for the loan repayment.
    */
-  function _repayLoan(uint256 purePremiumWon, IEToken etk) internal returns (uint256) {
-    if (purePremiumWon < NEGLIGIBLE_AMOUNT) return purePremiumWon;
+  function _repayLoan(uint256 fundsAvailable_, IEToken etk) internal returns (uint256) {
     uint256 borrowedFromEtk = etk.getLoan(address(this));
-    if (borrowedFromEtk == 0) return purePremiumWon;
-    uint256 repayAmount = Math.min(purePremiumWon, borrowedFromEtk);
+    if (borrowedFromEtk == 0) return fundsAvailable_;
+    uint256 repayAmount = Math.min(fundsAvailable_, borrowedFromEtk);
+    _surplus -= int256(repayAmount);
 
     // If not enough liquidity, it deinvests from the asset manager
     if (currency().balanceOf(address(this)) < repayAmount) {
@@ -567,7 +586,7 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
       currency().approve(address(etk), borrowedFromEtk);
     }
     etk.repayLoan(repayAmount, address(this));
-    return purePremiumWon - repayAmount;
+    return fundsAvailable_ - repayAmount;
   }
 
   function policyExpired(Policy.PolicyData memory policy)
@@ -576,22 +595,8 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     onlyPolicyPool
     whenNotPaused
   {
-    uint256 purePremiumWon = policy.purePremium;
-    _activePurePremiums -= purePremiumWon;
-
-    // If negative _activePurePremiums, repay this first (shouldn't happen)
-    int256 maxDeficit = _maxDeficit(deficitRatio());
-    if (_surplus < maxDeficit) {
-      // Covers the excess of deficit first
-      purePremiumWon -= uint256(-_surplus + maxDeficit);
-      _surplus = maxDeficit;
-    }
-
-    if (address(_seniorEtk) != address(0)) purePremiumWon = _repayLoan(purePremiumWon, _seniorEtk);
-    if (address(_juniorEtk) != address(0)) purePremiumWon = _repayLoan(purePremiumWon, _juniorEtk);
-
-    // Finally store purePremiumWon
-    _storePurePremiumWon(purePremiumWon);
+    _activePurePremiums -= policy.purePremium;
+    _storePurePremiumWon(policy.purePremium);
     _unlockScr(policy);
   }
 

package/contracts/RiskModule.sol

@@ -26,8 +26,8 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
 
   uint256 internal constant FOUR_DECIMAL_TO_WAD = 1e14;
   uint16 internal constant HUNDRED_PERCENT = 1e4;
-  uint16 internal constant MIN_MOC = 5e3;
-  uint16 internal constant MAX_MOC = 4e4;
+  uint16 internal constant MIN_MOC = 5e3; // 50%
+  uint16 internal constant MAX_MOC = 4e4; // 400%
 
   // For parameters that can be changed by the risk module provider
   bytes32 public constant RM_PROVIDER_ROLE = keccak256("RM_PROVIDER_ROLE");
@@ -339,7 +339,8 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
   }
 
   /**
-   * @dev Called from child contracts to create policies (after they validated the pricing)
+   * @dev Called from child contracts to create policies (after they validated the pricing).
+   *      whenNotPaused validation must be done in the external method.
    *
    * @param payout The exposure (maximum payout) of the policy
    * @param premium The premium that will be paid by the policyHolder
@@ -357,7 +358,7 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
     address payer,
     address onBehalfOf,
     uint96 internalId
-  ) internal whenNotPaused returns (Policy.PolicyData memory) {
+  ) internal virtual returns (Policy.PolicyData memory) {
     return
       _newPolicyWithParams(
         payout,
@@ -371,40 +372,6 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
       );
   }
 
-  /**
-   * @dev Called from child contracts to create policies (after they validated the pricing), receives custom params
-   *
-   * @param payout The exposure (maximum payout) of the policy
-   * @param premium The premium that will be paid by the policyHolder
-   * @param lossProb The probability of having to pay the maximum payout (wad)
-   * @param payer The account that pays for the premium
-   * @param expiration The expiration of the policy (timestamp)
-   * @param onBehalfOf The policy holder
-   * @param internalId An id that's unique within this module and it will be used to identify the policy
-   */
-  function _newPolicyCustomParams(
-    uint256 payout,
-    uint256 premium,
-    uint256 lossProb,
-    uint40 expiration,
-    address payer,
-    address onBehalfOf,
-    uint96 internalId,
-    Params memory params_
-  ) internal whenNotPaused returns (Policy.PolicyData memory) {
-    return
-      _newPolicyWithParams(
-        payout,
-        premium,
-        lossProb,
-        expiration,
-        payer,
-        onBehalfOf,
-        internalId,
-        params_
-      );
-  }
-
   /**
    * @dev Internal method without whenNotPaused, MUST be called from other function that has this modifier
    */

package/contracts/SignedQuoteRiskModule.sol

@@ -159,7 +159,7 @@ contract SignedQuoteRiskModule is RiskModule {
     bytes32 quoteSignatureR,
     bytes32 quoteSignatureVS,
     uint40 quoteValidUntil
-  ) external returns (Policy.PolicyData memory createdPolicy) {
+  ) external whenNotPaused returns (Policy.PolicyData memory createdPolicy) {
     return
       _newPolicySigned(
         payout,
@@ -207,7 +207,7 @@ contract SignedQuoteRiskModule is RiskModule {
     bytes32 quoteSignatureR,
     bytes32 quoteSignatureVS,
     uint40 quoteValidUntil
-  ) external returns (uint256) {
+  ) external whenNotPaused returns (uint256) {
     return
       _newPolicySigned(
         payout,
@@ -255,7 +255,7 @@ contract SignedQuoteRiskModule is RiskModule {
     bytes32 quoteSignatureR,
     bytes32 quoteSignatureVS,
     uint40 quoteValidUntil
-  ) external returns (uint256) {
+  ) external whenNotPaused returns (uint256) {
     require(
       onBehalfOf == _msgSender() || currency().allowance(onBehalfOf, _msgSender()) > 0,
       "Sender is not authorized to create policies onBehalfOf"

package/contracts/TieredSignedQuoteRiskModule.sol

@@ -0,0 +1,165 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
+import {IPremiumsAccount} from "./interfaces/IPremiumsAccount.sol";
+import {SignedQuoteRiskModule} from "./SignedQuoteRiskModule.sol";
+import {Policy} from "./Policy.sol";
+
+/**
+ * @title Tiered SignedQuote Risk Module
+ * @dev Risk Module that for policy creation verifies the different components of the price have been signed by a
+ *      trusted account (PRICER_ROLE). For the resolution (resolvePolicy), it has to be called by an authorized user.
+ *
+ *      It allows different collaterallization levels for different policy types, by defining tiers or buckets of loss
+ *      probability.
+ *
+ *      Each bucket's loss probability represents the upper bound of the bucket (inclusive). The global parameters of
+ *      the contract represent the 100% bucket.
+ *
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+contract TieredSignedQuoteRiskModule is SignedQuoteRiskModule {
+  using SafeCast for uint256;
+
+  uint8 public constant MAX_BUCKETS = 4;
+
+  struct PackedBuckets {
+    uint64[MAX_BUCKETS] lossProbs;
+  }
+
+  PackedBuckets internal _buckets;
+  PackedParams[MAX_BUCKETS] internal _bucketParams;
+
+  /**
+   * @dev Emitted when a new risk bucket is created.
+   * @param lossProb The loss probability of the new bucket.
+   * @param params The packed parameters of the new bucket.
+   */
+  event NewBucket(uint256 lossProb, Params params);
+
+  /**
+   * @dev Emitted when the risks buckets are reset and only the default one remains
+   */
+  event BucketsReset();
+
+  /// @custom:oz-upgrades-unsafe-allow constructor
+  constructor(
+    IPolicyPool policyPool_,
+    IPremiumsAccount premiumsAccount_,
+    bool creationIsOpen_
+  ) SignedQuoteRiskModule(policyPool_, premiumsAccount_, creationIsOpen_) {} // solhint-disable-line no-empty-blocks
+
+  /**
+   * @dev Adds a new risk bucket with the given loss probability and parameters after the last one.
+   *
+   * Requirements:
+   *
+   * - The caller must have the LEVEL1_ROLE or LEVEL2_ROLE
+   *
+   * @param lossProb The loss probability of the new bucket.
+   * @param params_ The parameters of the new bucket.
+   */
+  function pushBucket(uint256 lossProb, Params calldata params_)
+    external
+    onlyGlobalOrComponentRole2(LEVEL1_ROLE, LEVEL2_ROLE)
+  {
+    uint256 newBucket = 0;
+    if (_buckets.lossProbs[0] != 0) {
+      for (
+        newBucket = 1;
+        newBucket < MAX_BUCKETS && _buckets.lossProbs[newBucket] != 0;
+        newBucket++
+      ) {} // solhint-disable-line no-empty-blocks
+      require(newBucket < MAX_BUCKETS, "No more than 4 buckets accepted");
+      require(
+        lossProb > uint256(_buckets.lossProbs[newBucket - 1]),
+        "lossProb <= last lossProb - reset instead"
+      );
+    }
+    _buckets.lossProbs[newBucket] = lossProb.toUint64();
+    _bucketParams[newBucket] = PackedParams({
+      moc: _wadTo4(params_.moc),
+      jrCollRatio: _wadTo4(params_.jrCollRatio),
+      collRatio: _wadTo4(params_.collRatio),
+      ensuroPpFee: _wadTo4(params_.ensuroPpFee),
+      ensuroCocFee: _wadTo4(params_.ensuroCocFee),
+      jrRoc: _wadTo4(params_.jrRoc),
+      srRoc: _wadTo4(params_.srRoc),
+      maxPayoutPerPolicy: type(uint32).max, // unused, but needs to be > 0
+      exposureLimit: type(uint32).max, //unused, but needs to be > 0
+      maxDuration: type(uint16).max //unused
+    });
+    if (newBucket < MAX_BUCKETS - 1) {
+      _buckets.lossProbs[newBucket + 1] = 0;
+    }
+    _validatePackedParams(_bucketParams[newBucket]);
+    emit NewBucket(lossProb, params_);
+  }
+
+  function resetBuckets() external onlyGlobalOrComponentRole2(LEVEL1_ROLE, LEVEL2_ROLE) {
+    _buckets.lossProbs[0] = 0;
+    emit BucketsReset();
+  }
+
+  /**
+   * @dev returns the risk bucket parameters for the given loss probability
+   */
+  function bucketParams(uint256 lossProb) public view returns (Params memory) {
+    for (uint256 i = 0; i < MAX_BUCKETS && _buckets.lossProbs[i] != 0; i++) {
+      if (lossProb <= _buckets.lossProbs[i]) {
+        return _unpackParams(_bucketParams[i]);
+      }
+    }
+    return this.params();
+  }
+
+  function _newPolicy(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    address payer,
+    address onBehalfOf,
+    uint96 internalId
+  ) internal override whenNotPaused returns (Policy.PolicyData memory) {
+    return
+      _newPolicyWithParams(
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        payer,
+        onBehalfOf,
+        internalId,
+        bucketParams(lossProb)
+      );
+  }
+
+  function getMinimumPremium(
+    uint256 payout,
+    uint256 lossProb,
+    uint40 expiration
+  ) public view virtual override returns (uint256) {
+    return _getMinimumPremium(payout, lossProb, expiration, bucketParams(lossProb));
+  }
+
+  /**
+   * @dev returns the current risk bucket limits
+   */
+  function buckets() external view returns (uint256[MAX_BUCKETS] memory result) {
+    for (uint256 i = 0; i < MAX_BUCKETS && _buckets.lossProbs[i] > 0; i++) {
+      result[i] = _buckets.lossProbs[i];
+    }
+    return result;
+  }
+
+  /**
+   * @dev This empty reserved space is put in place to allow future versions to add new
+   * variables without shifting down storage in the inheritance chain.
+   * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+   */
+  uint256[45] private __gap;
+}

package/contracts/TrustfulRiskModule.sol

@@ -78,7 +78,7 @@ contract TrustfulRiskModule is RiskModule {
     uint40 expiration,
     address onBehalfOf,
     uint96 internalId
-  ) external onlyComponentRole(PRICER_ROLE) returns (uint256) {
+  ) external whenNotPaused onlyComponentRole(PRICER_ROLE) returns (uint256) {
     return
       _newPolicy(
         payout,
@@ -115,7 +115,12 @@ contract TrustfulRiskModule is RiskModule {
     uint40 expiration,
     address onBehalfOf,
     uint96 internalId
-  ) external onlyComponentRole(PRICER_ROLE) returns (Policy.PolicyData memory createdPolicy) {
+  )
+    external
+    whenNotPaused
+    onlyComponentRole(PRICER_ROLE)
+    returns (Policy.PolicyData memory createdPolicy)
+  {
     return
       _newPolicy(
         payout,

package/js/deploy.js

@@ -1,7 +1,7 @@
 const upgrades_core = require("@openzeppelin/upgrades-core");
 const helpers = require("@nomicfoundation/hardhat-network-helpers");
 const fs = require("fs");
-
+const { request } = require("undici");
 const ethers = require("ethers");
 
 const _BN = ethers.BigNumber.from;
@@ -14,6 +14,10 @@ const WhitelistStatus = {
   blacklisted: 2,
 };
 
+const reservesOpts = {
+  unsafeAllow: ["delegatecall"],
+};
+
 /**
  * Creates a fixed-point conversion function for the desired number of decimals
  * @param decimals The number of decimals. Must be >= 6.
@@ -115,10 +119,28 @@ async function verifyContract(hre, contract, isProxy, constructorArguments) {
       constructorArguments: constructorArguments,
     });
     if (isProxy) {
-      console.log(
-        "Contract successfully verified, you should verify the proxy at " +
-          `${etherscanUrl()}/proxyContractChecker?a=${contract.address}`
-      );
+      // the following should work but it fails with the current @openzeppelin/hardhat-upgrades version (1.20.0)
+      // await hre.run("verify:verify", {
+      //   address: contract.address,
+      // });
+
+      // so we use the following workaround
+      const endpoints = await hre.run("verify:get-etherscan-endpoint");
+      const params = new URLSearchParams({
+        module: "contract",
+        action: "verifyproxycontract",
+        apiKey: hre.config.etherscan.apiKey,
+        address: contract.address,
+      });
+      const response = await request(endpoints.urls.apiURL, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: params.toString(),
+      });
+      if (response.statusCode != 200)
+        throw new Error(`Etherscan replied with ${response.statusCode}: ${await response.body.text()}`);
+      const body = await response.body.json();
+      if (body.status != 1) throw new Error(`Etherscan replied with ${body}`);
     }
   } catch (error) {
     console.log("Error verifying contract", error);
@@ -141,7 +163,7 @@ async function deployContract({ saveAddr, verify, contractClass, constructorArgs
 }
 
 async function deployProxyContract(
-  { saveAddr, verify, contractClass, constructorArgs, initializeArgs, initializer },
+  { saveAddr, verify, contractClass, constructorArgs, initializeArgs, initializer, deployProxyArgs },
   hre
 ) {
   const ContractFactory = await hre.ethers.getContractFactory(contractClass);
@@ -149,7 +171,7 @@ async function deployProxyContract(
     constructorArgs: constructorArgs,
     kind: "uups",
     initializer: initializer,
-    unsafeAllow: ["delegatecall"],
+    ...deployProxyArgs,
   });
   if (verify) {
     // From https://ethereum.stackexchange.com/a/119622/79726
@@ -266,6 +288,7 @@ async function deployEToken(
       contractClass: "EToken",
       constructorArgs: [poolAddress],
       initializeArgs: [etkName, etkSymbol, _W(maxUtilizationRate), _W(poolLoanInterestRate)],
+      deployProxyArgs: reservesOpts,
       ...opts,
     },
     hre
@@ -284,6 +307,7 @@ async function deployPremiumsAccount({ poolAddress, juniorEtk, seniorEtk, runAs,
       contractClass: "PremiumsAccount",
       constructorArgs: [poolAddress, juniorEtk, seniorEtk],
       initializeArgs: [],
+      deployProxyArgs: reservesOpts,
       ...opts,
     },
     hre