@ensuro/core 2.8.3 → 2.9.1

package/contracts/EToken.sol

@@ -697,31 +697,14 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     return _4toWad(_params.internalLoanInterestRate);
   }
 
-  function setParam(Parameter param, uint256 newValue) external onlyGlobalOrComponentRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
-    bool tweak = !hasPoolRole(LEVEL2_ROLE);
+  function setParam(Parameter param, uint256 newValue) external onlyGlobalOrComponentRole(LEVEL2_ROLE) {
     if (param == Parameter.liquidityRequirement) {
-      require(
-        !tweak || _isTweakWad(liquidityRequirement(), newValue, 1e17),
-        "Tweak exceeded: liquidityRequirement tweaks only up to 10%"
-      );
       _params.liquidityRequirement = _wadTo4(newValue);
     } else if (param == Parameter.minUtilizationRate) {
-      require(
-        !tweak || _isTweakWad(minUtilizationRate(), newValue, 3e17),
-        "Tweak exceeded: minUtilizationRate tweaks only up to 30%"
-      );
       _params.minUtilizationRate = _wadTo4(newValue);
     } else if (param == Parameter.maxUtilizationRate) {
-      require(
-        !tweak || _isTweakWad(maxUtilizationRate(), newValue, 3e17),
-        "Tweak exceeded: maxUtilizationRate tweaks only up to 30%"
-      );
       _params.maxUtilizationRate = _wadTo4(newValue);
     } else if (param == Parameter.internalLoanInterestRate) {
-      require(
-        !tweak || _isTweakWad(internalLoanInterestRate(), newValue, 3e17),
-        "Tweak exceeded: internalLoanInterestRate tweaks only up to 30%"
-      );
       // This call changes the interest rate without updating the current loans up to this point
       // So, if interest rate goes from 5% to 6%, this change will be retroactive to the lastUpdate of each
       // loan. Since it's a permissioned call, I'm ok with this. If a caller wants to reduce the impact, it can
@@ -732,8 +715,7 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
       IAccessManager.GovernanceActions(
         uint256(IAccessManager.GovernanceActions.setLiquidityRequirement) + uint256(param)
       ),
-      newValue,
-      tweak
+      newValue
     );
   }
 

package/contracts/FullSignedBucketRiskModule.sol

@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+
+import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
+import {IPremiumsAccount} from "./interfaces/IPremiumsAccount.sol";
+import {Policy} from "./Policy.sol";
+import {SignedBucketRiskModule} from "./SignedBucketRiskModule.sol";
+
+/**
+ * @title FullSignedBucket Risk Module
+ * @dev Variation of SignedBucketRiskModule that also supports the creation of policies receiving all the
+        parameters that affect the price (not just the lossProb). And validates the signature.
+        It requires a new permission, the FULL_PRICER_ROLE.
+  * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+contract FullSignedBucketRiskModule is SignedBucketRiskModule {
+  bytes32 internal constant FULL_PRICER_ROLE = keccak256("FULL_PRICER_ROLE");
+
+  /// @custom:oz-upgrades-unsafe-allow constructor
+  constructor(
+    IPolicyPool policyPool_,
+    IPremiumsAccount premiumsAccount_
+  ) SignedBucketRiskModule(policyPool_, premiumsAccount_) {}
+
+  function _paramsAsUint256(PackedParams memory overrideParams) internal pure returns (uint256) {
+    return
+      (uint256(overrideParams.moc) << 240) |
+      (uint256(overrideParams.jrCollRatio) << 224) |
+      (uint256(overrideParams.collRatio) << 208) |
+      (uint256(overrideParams.ensuroPpFee) << 192) |
+      (uint256(overrideParams.ensuroCocFee) << 176) |
+      (uint256(overrideParams.jrRoc) << 160) |
+      (uint256(overrideParams.srRoc) << 144);
+  }
+
+  function _checkFullSignature(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    bytes32 policyData,
+    PackedParams memory params,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil
+  ) internal view {
+    if (quoteValidUntil < block.timestamp) revert QuoteExpired();
+
+    /**
+     * Checks the quote has been signed by an authorized user
+     * The "quote" is computed as hash of the following fields (encodePacked):
+     * - address(this): the address of this RiskModule
+     * - payout, premium, lossProb, expiration: the base parameters of the policy
+     * - policyData: a hash of the private details of the policy. The calculation should include some
+     *   unique id (quoteId), so each policyData identifies a policy.
+     * - params: packed as a uint256
+     * - quoteValidUntil: the maximum validity of the quote
+     */
+    bytes32 quoteHash = ECDSA.toEthSignedMessageHash(
+      abi.encodePacked(
+        address(this),
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        policyData,
+        _paramsAsUint256(params),
+        quoteValidUntil
+      )
+    );
+    address signer = ECDSA.recover(quoteHash, quoteSignatureR, quoteSignatureVS);
+    _policyPool.access().checkComponentRole(address(this), FULL_PRICER_ROLE, signer, false);
+  }
+
+  /**
+   * @dev Creates a new Policy using a full signed quote that overrides params.
+   *      The caller is the payer of the policy.
+   *
+   * Requirements:
+   * - The caller approved the spending of the premium to the PolicyPool
+   * - The quote has been signed by an address with the component role PRICER_ROLE
+   *
+   * Emits:
+   * - {PolicyPool.NewPolicy}
+   * - {NewSignedPolicy}
+   *
+   * @param payout The exposure (maximum payout) of the policy
+   * @param premium The premium that will be paid by the payer
+   * @param lossProb The probability of having to pay the maximum payout (wad)
+   * @param expiration The expiration of the policy (timestamp)
+   * @param onBehalfOf The policy holder
+   * @param policyData A hash of the private details of the policy. The last 96 bits will be used as internalId
+   * @param params The parameters for the policy creation (coll ratios, RoCs, fees, etc.)
+   * @param quoteSignatureR The signature of the quote. R component (EIP-2098 signature)
+   * @param quoteSignatureVS The signature of the quote. VS component (EIP-2098 signature)
+   * @param quoteValidUntil The expiration of the quote
+   * @return createdPolicy Returns the created policy
+   */
+  function newPolicyFullParams(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    address onBehalfOf,
+    bytes32 policyData,
+    PackedParams memory params,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil
+  ) external whenNotPaused onlyComponentRole(POLICY_CREATOR_ROLE) returns (Policy.PolicyData memory createdPolicy) {
+    _checkFullSignature(
+      payout,
+      premium,
+      lossProb,
+      expiration,
+      policyData,
+      params,
+      quoteSignatureR,
+      quoteSignatureVS,
+      quoteValidUntil
+    );
+    createdPolicy = _newPolicyWithParams(
+      payout,
+      premium,
+      lossProb,
+      expiration,
+      _msgSender(),
+      onBehalfOf,
+      _makeInternalId(policyData),
+      _unpackParams(params)
+    );
+    emit NewSignedPolicy(createdPolicy.id, policyData);
+  }
+
+  /**
+   * @dev Replace a policy with a new one, reusing the premium and the capital locked
+   *
+   * Requirements:
+   * - The caller approved the spending of the premium to the PolicyPool
+   * - The quote has been signed by an address with the component role PRICER_ROLE
+   * - The caller has been granted component role REPLACER_ROLE or creation is open
+   *
+   * Emits:
+   * - {PolicyPool.PolicyReplaced}
+   * - {PolicyPool.NewPolicy}
+   *
+   * @param oldPolicy The policy to be replaced
+   * @param payout The exposure (maximum payout) of the new policy
+   * @param premium The premium that will be paid by the caller
+   * @param lossProb The probability of having to pay the maximum payout (wad)
+   * @param expiration The expiration of the policy (timestamp)
+   * @param policyData A hash of the private details of the policy. The last 96 bits will be used as internalId
+   * @param params The parameters for the policy creation (coll ratios, RoCs, fees, etc.)
+   * @param quoteSignatureR The signature of the quote. R component (EIP-2098 signature)
+   * @param quoteSignatureVS The signature of the quote. VS component (EIP-2098 signature)
+   * @param quoteValidUntil The expiration of the quote
+   * @return Returns the id of the created policy
+   */
+  function replacePolicyFullParams(
+    Policy.PolicyData calldata oldPolicy,
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    bytes32 policyData,
+    PackedParams memory params,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil
+  ) external whenNotPaused onlyComponentRole(REPLACER_ROLE) returns (uint256) {
+    _checkFullSignature(
+      payout,
+      premium,
+      lossProb,
+      expiration,
+      policyData,
+      params,
+      quoteSignatureR,
+      quoteSignatureVS,
+      quoteValidUntil
+    );
+    return
+      _replacePolicy(
+        oldPolicy,
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        _msgSender(),
+        _makeInternalId(policyData),
+        _unpackParams(params)
+      ).id;
+  }
+
+  /**
+   * @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[50] private __gap;
+}

package/contracts/PolicyPool.sol

@@ -42,7 +42,6 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable, ERC721
   bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");
   bytes32 public constant LEVEL1_ROLE = keccak256("LEVEL1_ROLE");
   bytes32 public constant LEVEL2_ROLE = keccak256("LEVEL2_ROLE");
-  bytes32 public constant LEVEL3_ROLE = keccak256("LEVEL3_ROLE");
 
   uint256 internal constant HOLDER_GAS_LIMIT = 150000;
 

package/contracts/PolicyPoolComponent.sol

@@ -17,7 +17,6 @@ import {WadRayMath} from "./dependencies/WadRayMath.sol";
  *      Holds the reference to _policyPool as immutable, also provides access to common admin roles:
  *      - LEVEL1_ROLE: High impact changes like upgrades, adding or removing components or other critical operations
  *      - LEVEL2_ROLE: Mid-impact changes like changing some parameters
- *      - LEVEL3_ROLE: Low-impact changes like changing some parameters up to given percentage (tweaks)
  *      - GUARDIAN_ROLE: For emergency operations oriented to protect the protocol in case of attacks or hacking.
  *
  *      This contract also keeps track of the tweaks to avoid two tweaks of the same type are done in a short period.
@@ -27,26 +26,22 @@ import {WadRayMath} from "./dependencies/WadRayMath.sol";
 abstract contract PolicyPoolComponent is UUPSUpgradeable, PausableUpgradeable, IPolicyPoolComponent {
   using WadRayMath for uint256;
 
-  bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");
-  bytes32 public constant LEVEL1_ROLE = keccak256("LEVEL1_ROLE");
-  bytes32 public constant LEVEL2_ROLE = keccak256("LEVEL2_ROLE");
-  bytes32 public constant LEVEL3_ROLE = keccak256("LEVEL3_ROLE");
-
-  uint40 public constant TWEAK_EXPIRATION = 1 days;
+  bytes32 internal constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");
+  bytes32 internal constant LEVEL1_ROLE = keccak256("LEVEL1_ROLE");
+  bytes32 internal constant LEVEL2_ROLE = keccak256("LEVEL2_ROLE");
 
   /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
   IPolicyPool internal immutable _policyPool;
-  uint40 internal _lastTweakTimestamp;
-  uint56 internal _lastTweakActions; // bitwise map of applied actions
 
   event GovernanceAction(IAccessManager.GovernanceActions indexed action, uint256 value);
   event ComponentChanged(IAccessManager.GovernanceActions indexed action, address value);
 
   error NoZeroPolicyPool();
   error UpgradeCannotChangePolicyPool();
+  error OnlyPolicyPool();
 
   modifier onlyPolicyPool() {
-    require(_msgSender() == address(_policyPool), "The caller must be the PolicyPool");
+    require(_msgSender() == address(_policyPool), OnlyPolicyPool());
     _;
   }
 
@@ -65,18 +60,6 @@ abstract contract PolicyPoolComponent is UUPSUpgradeable, PausableUpgradeable, I
     _;
   }
 
-  modifier onlyGlobalOrComponentRole3(
-    bytes32 role1,
-    bytes32 role2,
-    bytes32 role3
-  ) {
-    IAccessManager access = _policyPool.access();
-    if (!access.hasComponentRole(address(this), role1, _msgSender(), true)) {
-      _policyPool.access().checkComponentRole2(address(this), role2, role3, _msgSender(), true);
-    }
-    _;
-  }
-
   /// @custom:oz-upgrades-unsafe-allow constructor
   constructor(IPolicyPool policyPool_) {
     if (address(policyPool_) == address(0)) revert NoZeroPolicyPool();
@@ -141,9 +124,8 @@ abstract contract PolicyPoolComponent is UUPSUpgradeable, PausableUpgradeable, I
   // solhint-disable-next-line no-empty-blocks
   function _validateParameters() internal view virtual {} // Must be reimplemented with specific validations
 
-  function _parameterChanged(IAccessManager.GovernanceActions action, uint256 value, bool tweak) internal {
+  function _parameterChanged(IAccessManager.GovernanceActions action, uint256 value) internal {
     _validateParameters();
-    if (tweak) _registerTweak(action);
     emit GovernanceAction(action, value);
   }
 
@@ -152,29 +134,10 @@ abstract contract PolicyPoolComponent is UUPSUpgradeable, PausableUpgradeable, I
     emit ComponentChanged(action, value);
   }
 
-  function lastTweak() external view returns (uint40, uint56) {
-    return (_lastTweakTimestamp, _lastTweakActions);
-  }
-
-  function _registerTweak(IAccessManager.GovernanceActions action) internal {
-    uint56 actionBitMap = uint56(1 << (uint8(action) - 1));
-    if ((uint40(block.timestamp) - _lastTweakTimestamp) > TWEAK_EXPIRATION) {
-      _lastTweakTimestamp = uint40(block.timestamp);
-      _lastTweakActions = actionBitMap;
-    } else {
-      if ((actionBitMap & _lastTweakActions) == 0) {
-        _lastTweakActions |= actionBitMap;
-        _lastTweakTimestamp = uint40(block.timestamp); // Updates the expiration
-      } else {
-        revert("You already tweaked this parameter recently. Wait before tweaking again");
-      }
-    }
-  }
-
   /**
    * @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[49] private __gap;
+  uint256[50] private __gap;
 }

package/contracts/PremiumsAccount.sol

@@ -329,7 +329,7 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
       _borrowFromEtk(borrow, address(this), address(_juniorEtk) != address(0));
       action = IAccessManager.GovernanceActions.setDeficitRatioWithAdjustment;
     }
-    _parameterChanged(action, newRatio, false);
+    _parameterChanged(action, newRatio);
   }
 
   /**
@@ -350,12 +350,12 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     if (newLimitJr != type(uint256).max) {
       _params.jrLoanLimit = _toZeroDecimals(newLimitJr);
       require(_toAmount(_params.jrLoanLimit) == newLimitJr, "Validation: no decimals allowed");
-      _parameterChanged(IAccessManager.GovernanceActions.setJrLoanLimit, newLimitJr, false);
+      _parameterChanged(IAccessManager.GovernanceActions.setJrLoanLimit, newLimitJr);
     }
     if (newLimitSr != type(uint256).max) {
       _params.srLoanLimit = _toZeroDecimals(newLimitSr);
       require(_toAmount(_params.srLoanLimit) == newLimitSr, "Validation: no decimals allowed");
-      _parameterChanged(IAccessManager.GovernanceActions.setSrLoanLimit, newLimitSr, false);
+      _parameterChanged(IAccessManager.GovernanceActions.setSrLoanLimit, newLimitSr);
     }
   }
 

package/contracts/RiskModule.sol

@@ -30,7 +30,7 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
   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");
+  bytes32 internal constant RM_PROVIDER_ROLE = keccak256("RM_PROVIDER_ROLE");
 
   /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
   IPremiumsAccount internal immutable _premiumsAccount;
@@ -206,48 +206,33 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
     return _wallet;
   }
 
-  function setParam(
-    Parameter param,
-    uint256 newValue
-  ) external onlyGlobalOrComponentRole3(LEVEL1_ROLE, LEVEL2_ROLE, LEVEL3_ROLE) {
-    bool tweak = !hasPoolRole(LEVEL2_ROLE) && !hasPoolRole(LEVEL1_ROLE);
+  function setParam(Parameter param, uint256 newValue) external onlyGlobalOrComponentRole2(LEVEL1_ROLE, LEVEL2_ROLE) {
     if (param == Parameter.moc) {
-      require(!tweak || _isTweakWad(_4toWad(_params.moc), newValue, 1e17), "Tweak exceeded");
       _params.moc = _wadTo4(newValue);
     } else if (param == Parameter.jrCollRatio) {
-      require(!tweak || _isTweakWad(_4toWad(_params.jrCollRatio), newValue, 1e17), "Tweak exceeded");
       _params.jrCollRatio = _wadTo4(newValue);
     } else if (param == Parameter.collRatio) {
-      require(!tweak || _isTweakWad(_4toWad(_params.collRatio), newValue, 1e17), "Tweak exceeded");
       _params.collRatio = _wadTo4(newValue);
     } else if (param == Parameter.ensuroPpFee) {
-      require(!tweak || _isTweakWad(_4toWad(_params.ensuroPpFee), newValue, 1e17), "Tweak exceeded");
       _params.ensuroPpFee = _wadTo4(newValue);
     } else if (param == Parameter.ensuroCocFee) {
-      require(!tweak || _isTweakWad(_4toWad(_params.ensuroCocFee), newValue, 1e17), "Tweak exceeded");
       _params.ensuroCocFee = _wadTo4(newValue);
     } else if (param == Parameter.jrRoc) {
-      require(!tweak || _isTweakWad(_4toWad(_params.jrRoc), newValue, 1e17), "Tweak exceeded");
       _params.jrRoc = _wadTo4(newValue);
     } else if (param == Parameter.srRoc) {
-      require(!tweak || _isTweakWad(_4toWad(_params.srRoc), newValue, 1e17), "Tweak exceeded");
       _params.srRoc = _wadTo4(newValue);
     } else if (param == Parameter.maxPayoutPerPolicy) {
-      require(!tweak || _isTweakWad(maxPayoutPerPolicy(), newValue, 1e17), "Tweak exceeded");
       _params.maxPayoutPerPolicy = _amountToX(2, newValue);
     } else if (param == Parameter.exposureLimit) {
       require(newValue >= _activeExposure, "Can't set exposureLimit less than active exposure");
-      require(!tweak || _isTweakWad(exposureLimit(), newValue, 1e17), "Tweak exceeded");
-      require(newValue <= exposureLimit() || hasPoolRole(LEVEL1_ROLE), "Tweak exceeded: Increase requires LEVEL1_ROLE");
+      require(newValue <= exposureLimit() || hasPoolRole(LEVEL1_ROLE), "Increase requires LEVEL1_ROLE");
       _params.exposureLimit = _amountToX(0, newValue);
     } else if (param == Parameter.maxDuration) {
-      require(!tweak, "Tweak exceeded");
       _params.maxDuration = newValue.toUint16();
     }
     _parameterChanged(
       IAccessManager.GovernanceActions(uint256(IAccessManager.GovernanceActions.setMoc) + uint256(param)),
-      newValue,
-      tweak
+      newValue
     );
   }
 
@@ -255,7 +240,7 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
     return _unpackParams(_params);
   }
 
-  function _unpackParams(PackedParams storage params_) internal view returns (Params memory ret) {
+  function _unpackParams(PackedParams memory params_) internal pure returns (Params memory ret) {
     return
       Params({
         moc: _4toWad(params_.moc),
@@ -268,12 +253,16 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
       });
   }
 
+  function _makeInternalId(bytes32 policyData) internal pure returns (uint96) {
+    return uint96(uint256(policyData) % 2 ** 96);
+  }
+
   function setWallet(address wallet_) external onlyComponentRole(RM_PROVIDER_ROLE) {
     if (wallet_ == address(0)) {
       revert NoZeroWallet();
     }
     _wallet = wallet_;
-    _parameterChanged(IAccessManager.GovernanceActions.setWallet, uint256(uint160(wallet_)), false);
+    _parameterChanged(IAccessManager.GovernanceActions.setWallet, uint256(uint160(wallet_)));
   }
 
   function getMinimumPremium(

package/contracts/SignedBucketRiskModule.sol

@@ -18,10 +18,10 @@ import {RiskModule} from "./RiskModule.sol";
  * @author Ensuro
  */
 contract SignedBucketRiskModule is RiskModule {
-  bytes32 public constant POLICY_CREATOR_ROLE = keccak256("POLICY_CREATOR_ROLE");
-  bytes32 public constant REPLACER_ROLE = keccak256("REPLACER_ROLE");
-  bytes32 public constant PRICER_ROLE = keccak256("PRICER_ROLE");
-  bytes32 public constant RESOLVER_ROLE = keccak256("RESOLVER_ROLE");
+  bytes32 internal constant POLICY_CREATOR_ROLE = keccak256("POLICY_CREATOR_ROLE");
+  bytes32 internal constant REPLACER_ROLE = keccak256("REPLACER_ROLE");
+  bytes32 internal constant PRICER_ROLE = keccak256("PRICER_ROLE");
+  bytes32 internal constant RESOLVER_ROLE = keccak256("RESOLVER_ROLE");
 
   mapping(uint256 => PackedParams) internal _buckets;
 
@@ -114,7 +114,6 @@ contract SignedBucketRiskModule is RiskModule {
     address payer,
     address onBehalfOf
   ) internal returns (Policy.PolicyData memory createdPolicy) {
-    uint96 internalId = uint96(uint256(policyData) % 2 ** 96);
     createdPolicy = _newPolicyWithParams(
       payout,
       premium,
@@ -122,7 +121,7 @@ contract SignedBucketRiskModule is RiskModule {
       expiration,
       payer,
       onBehalfOf,
-      internalId,
+      _makeInternalId(policyData),
       bucketParams(bucketId)
     );
     emit NewSignedPolicy(createdPolicy.id, policyData);
@@ -225,10 +224,17 @@ contract SignedBucketRiskModule is RiskModule {
       quoteSignatureVS,
       quoteValidUntil
     );
-    uint96 internalId = uint96(uint256(policyData) % 2 ** 96);
     return
-      _replacePolicy(oldPolicy, payout, premium, lossProb, expiration, _msgSender(), internalId, bucketParams(bucketId))
-        .id;
+      _replacePolicy(
+        oldPolicy,
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        _msgSender(),
+        _makeInternalId(policyData),
+        bucketParams(bucketId)
+      ).id;
   }
 
   function resolvePolicy(

package/contracts/SignedQuoteRiskModule.sol

@@ -91,11 +91,14 @@ contract SignedQuoteRiskModule is RiskModule {
     bytes32 quoteHash = ECDSA.toEthSignedMessageHash(
       abi.encodePacked(address(this), payout, premium, lossProb, expiration, policyData, quoteValidUntil)
     );
-    address signer = ECDSA.recover(quoteHash, quoteSignatureR, quoteSignatureVS);
-    _policyPool.access().checkComponentRole(address(this), PRICER_ROLE, signer, false);
-    uint96 internalId = uint96(uint256(policyData) % 2 ** 96);
+    _policyPool.access().checkComponentRole(
+      address(this),
+      PRICER_ROLE,
+      ECDSA.recover(quoteHash, quoteSignatureR, quoteSignatureVS),
+      false
+    );
 
-    createdPolicy = _newPolicy(payout, premium, lossProb, expiration, payer, onBehalfOf, internalId);
+    createdPolicy = _newPolicy(payout, premium, lossProb, expiration, payer, onBehalfOf, _makeInternalId(policyData));
     emit NewSignedPolicy(createdPolicy.id, policyData);
     return createdPolicy;
   }

package/js/deploy.js

@@ -3,7 +3,7 @@ const fs = require("fs");
 const ethers = require("ethers");
 const { task, types } = require("hardhat/config");
 const { WhitelistStatus } = require("../js/enums");
-const { amountFunction, _W, grantRole, grantComponentRole, getDefaultSigner } = require("../js/utils");
+const { amountFunction, _W, grantRole, grantComponentRole, getDefaultSigner } = require("@ensuro/utils/js/utils");
 
 const reservesOpts = {
   unsafeAllow: ["delegatecall"],

package/js/test-utils.js

@@ -1,48 +1,10 @@
 const hre = require("hardhat");
-const { _W, grantRole, getTransactionEvent } = require("../js/utils");
-const { RiskModuleParameter } = require("../js/enums");
-const helpers = require("@nomicfoundation/hardhat-network-helpers");
+const { _W, grantRole, getTransactionEvent } = require("@ensuro/utils/js/utils");
+const { RiskModuleParameter } = require("./enums");
 
 const { ethers } = hre;
 const { ZeroAddress } = ethers;
 
-async function initCurrency(options, initial_targets, initial_balances) {
-  const Currency = await ethers.getContractFactory(options.contractClass || "TestCurrency");
-  let currency = await Currency.deploy(
-    options.name || "Test Currency",
-    options.symbol || "TEST",
-    options.initial_supply,
-    options.decimals || 18
-  );
-  initial_targets = initial_targets || [];
-  await Promise.all(
-    initial_targets.map(async function (user, index) {
-      await currency.transfer(user, initial_balances[index]);
-    })
-  );
-  return currency;
-}
-
-/**
- *
- * @param currencyAddress The currency contract address, for example the USDC address
- * @param currencyOrigin An account that holds at least sum(initialBalances) of currency tokens
- * @param initialTargets Array of addresses that will receive the initial balances
- * @param initialBalances Initial balances for each address
- */
-async function initForkCurrency(currencyAddress, currencyOrigin, initialTargets, initialBalances) {
-  const currency = await ethers.getContractAt("IERC20", currencyAddress);
-  await helpers.impersonateAccount(currencyOrigin);
-  await helpers.setBalance(currencyOrigin, ethers.parseEther("100"));
-  const whale = await ethers.getSigner(currencyOrigin);
-  await Promise.all(
-    initialTargets.map(async function (user, index) {
-      await currency.connect(whale).transfer(user, initialBalances[index]);
-    })
-  );
-  return currency;
-}
-
 async function createRiskModule(
   pool,
   premiumsAccount,
@@ -227,7 +189,6 @@ async function deployPool(options) {
   if (options.dontGrantL123Roles === undefined) {
     await grantRole(hre, accessManager, "LEVEL1_ROLE");
     await grantRole(hre, accessManager, "LEVEL2_ROLE");
-    await grantRole(hre, accessManager, "LEVEL3_ROLE");
   }
 
   return policyPool;
@@ -259,52 +220,6 @@ async function makePolicy(pool, rm, cust, payout, premium, lossProb, expiration,
   return newPolicyEvt;
 }
 
-/**
- * Resets hardhat network to fork on the specified block and url
- */
-async function setupChain(block, alchemyUrlEnv = "ALCHEMY_URL") {
-  const alchemyUrl = process.env[alchemyUrlEnv];
-  if (alchemyUrl === undefined) throw new Error(`Define envvar ${alchemyUrlEnv} for this test`);
-
-  if (block === undefined) throw new Error("Block can't be undefined use null for the current block");
-  if (block === null) block = undefined;
-  return hre.network.provider.request({
-    method: "hardhat_reset",
-    params: [
-      {
-        forking: {
-          jsonRpcUrl: alchemyUrl,
-          blockNumber: block,
-        },
-      },
-    ],
-  });
-}
-
-const skipForkTests = process.env.SKIP_FORK_TESTS === "true";
-
-/**
- * Chai test case wrapper for tests that require forking a live chain.
- *
- * It validates that the chain node URL is set, forks the chain at the specified block and adds the
- * block number to the test name.
- */
-const fork = {
-  it: (name, blockNumber, test, alchemyUrlEnv = "ALCHEMY_URL") => {
-    const fullName = `[FORK ${blockNumber}] ${name}`;
-
-    // eslint-disable-next-line func-style
-    const wrapped = async (...args) => {
-      await setupChain(blockNumber, alchemyUrlEnv);
-
-      return test(...args);
-    };
-
-    return (skipForkTests ? it.skip : it)(fullName, wrapped);
-  },
-};
-
-if (process.env.ENABLE_HH_WARNINGS !== "yes") hre.upgrades.silenceWarnings();
 
 module.exports = {
   addEToken,
@@ -313,10 +228,5 @@ module.exports = {
   createRiskModule,
   deployPool,
   deployPremiumsAccount,
-  fork,
-  initCurrency,
-  initForkCurrency,
   makePolicy,
-  setupChain,
-  skipForkTests,
 };