@ensuro/core 1.2.7 → 2.0.0-beta10

package/contracts/SignedQuoteRiskModule.sol

@@ -0,0 +1,241 @@
+// 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 {RiskModule} from "./RiskModule.sol";
+import {Policy} from "./Policy.sol";
+
+/**
+ * @title 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
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+contract SignedQuoteRiskModule is RiskModule {
+  bytes32 public constant POLICY_CREATOR_ROLE = keccak256("POLICY_CREATOR_ROLE");
+  bytes32 public constant PRICER_ROLE = keccak256("PRICER_ROLE");
+  bytes32 public constant RESOLVER_ROLE = keccak256("RESOLVER_ROLE");
+
+  /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+  bool internal immutable _creationIsOpen;
+
+  event NewSignedPolicy(uint256 indexed policyId, bytes32 policyData);
+
+  /// @custom:oz-upgrades-unsafe-allow constructor
+  constructor(
+    IPolicyPool policyPool_,
+    IPremiumsAccount premiumsAccount_,
+    bool creationIsOpen_
+  ) RiskModule(policyPool_, premiumsAccount_) {
+    _creationIsOpen = creationIsOpen_;
+  }
+
+  /**
+   * @dev Initializes the RiskModule
+   * @param name_ Name of the Risk Module
+   * @param collRatio_ Collateralization ratio to compute solvency requirement as % of payout (in ray)
+   * @param ensuroPpFee_ % of pure premium that will go for Ensuro treasury (in ray)
+   * @param srRoc_ return on capital paid to Senior LPs (annualized percentage - in ray)
+   * @param maxPayoutPerPolicy_ Maximum payout per policy (in wad)
+   * @param exposureLimit_ Max exposure (sum of payouts) to be allocated to this module (in wad)
+   * @param wallet_ Address of the RiskModule provider
+   */
+  function initialize(
+    string memory name_,
+    uint256 collRatio_,
+    uint256 ensuroPpFee_,
+    uint256 srRoc_,
+    uint256 maxPayoutPerPolicy_,
+    uint256 exposureLimit_,
+    address wallet_
+  ) public initializer {
+    __RiskModule_init(
+      name_,
+      collRatio_,
+      ensuroPpFee_,
+      srRoc_,
+      maxPayoutPerPolicy_,
+      exposureLimit_,
+      wallet_
+    );
+  }
+
+  function _newPolicySigned(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    bytes32 policyData,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil,
+    address payer,
+    address onBehalfOf
+  ) internal returns (uint256 policyId) {
+    if (!_creationIsOpen)
+      _policyPool.access().checkComponentRole(
+        address(this),
+        POLICY_CREATOR_ROLE,
+        _msgSender(),
+        false
+      );
+    require(quoteValidUntil >= block.timestamp, "Quote expired");
+
+    /**
+     * 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.
+     * - quoteValidUntil: the maximum validity of the quote
+     */
+    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);
+
+    policyId = _newPolicy(payout, premium, lossProb, expiration, payer, onBehalfOf, internalId).id;
+    emit NewSignedPolicy(policyId, policyData);
+    return policyId;
+  }
+
+  /**
+   * @dev Creates a new Policy using a signed quote. 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 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 newPolicy(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    address onBehalfOf,
+    bytes32 policyData,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil
+  ) external returns (uint256) {
+    return
+      _newPolicySigned(
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        policyData,
+        quoteSignatureR,
+        quoteSignatureVS,
+        quoteValidUntil,
+        _msgSender(),
+        onBehalfOf
+      );
+  }
+
+  /**
+   * @dev Creates a new Policy using a signed quote. The payer is the policy holder
+   *
+   * Requirements:
+   * - currency().allowance(onBehalfOf, _msgSender()) > 0
+   * - 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 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 newPolicyPaidByHolder(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    address onBehalfOf,
+    bytes32 policyData,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil
+  ) external returns (uint256) {
+    require(
+      onBehalfOf == _msgSender() || currency().allowance(onBehalfOf, _msgSender()) > 0,
+      "Sender is not authorized to create policies onBehalfOf"
+    );
+    /**
+     * The standard is the payer should be the _msgSender() but usually, in this type of module,
+     * the sender is an operative account managed by software, where the onBehalfOf is a more
+     * secure account (hardware wallet) that does the cash movements.
+     * This non standard behaviour allows for a more secure setup, where the sender never manages
+     * cash.
+     * We leverage the currency's allowance mechanism to allow the sender access to the payer's
+     * funds.
+     * Note that this allowance won't be spent, so anything above 0 is accepted.
+     */
+    return
+      _newPolicySigned(
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        policyData,
+        quoteSignatureR,
+        quoteSignatureVS,
+        quoteValidUntil,
+        onBehalfOf,
+        onBehalfOf
+      );
+  }
+
+  function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout)
+    external
+    onlyComponentRole(RESOLVER_ROLE)
+    whenNotPaused
+  {
+    _policyPool.resolvePolicy(policy, payout);
+  }
+
+  function resolvePolicyFullPayout(Policy.PolicyData calldata policy, bool customerWon)
+    external
+    onlyComponentRole(RESOLVER_ROLE)
+    whenNotPaused
+  {
+    _policyPool.resolvePolicyFullPayout(policy, customerWon);
+  }
+}

package/contracts/TimeScaled.sol

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.8.0;
+
+import {WadRayMath} from "./dependencies/WadRayMath.sol";
+import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+
+/**
+ * @title TimeScaled
+ * @dev Library for packed amounts that increase continuoulsly with a scale factor
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+library TimeScaled {
+  using WadRayMath for uint256;
+  using SafeCast for uint256;
+
+  uint256 private constant SECONDS_PER_YEAR = 365 days;
+  uint112 private constant MIN_SCALE = 1e17; // 0.0000000001 == 1e-10 in ray
+  uint112 private constant RAY112 = 1e27;
+
+  struct ScaledAmount {
+    uint112 scale;
+    uint112 amount;
+    uint32 lastUpdate;
+  }
+
+  function updateScale(ScaledAmount storage scaledAmount, uint256 interestRate) internal {
+    if (scaledAmount.lastUpdate >= uint32(block.timestamp)) return;
+    if (scaledAmount.amount == 0) {
+      scaledAmount.lastUpdate = uint32(block.timestamp);
+    } else {
+      scaledAmount.scale = getScale(scaledAmount, interestRate).toUint112();
+      scaledAmount.lastUpdate = uint32(block.timestamp);
+    }
+  }
+
+  function getScale(ScaledAmount storage scaledAmount, uint256 interestRate)
+    internal
+    view
+    returns (uint256)
+  {
+    uint32 now_ = uint32(block.timestamp);
+    if (scaledAmount.lastUpdate >= now_) {
+      return scaledAmount.scale;
+    }
+    uint256 timeDifference = uint256(now_ - scaledAmount.lastUpdate);
+    return
+      uint256(scaledAmount.scale).rayMul(
+        ((interestRate.wadToRay() * timeDifference) / SECONDS_PER_YEAR) + WadRayMath.RAY
+      );
+  }
+
+  function getScaledAmount(ScaledAmount storage scaledAmount, uint256 interestRate)
+    internal
+    view
+    returns (uint256)
+  {
+    return
+      uint256(scaledAmount.amount)
+        .wadToRay()
+        .rayMul(getScale(scaledAmount, interestRate))
+        .rayToWad();
+  }
+
+  function init(ScaledAmount storage scaledAmount) internal {
+    scaledAmount.scale = RAY112;
+    scaledAmount.amount = 0;
+    scaledAmount.lastUpdate = uint32(block.timestamp);
+  }
+
+  function scaleAmount(ScaledAmount storage scaledAmount, uint256 toScale)
+    internal
+    view
+    returns (uint256)
+  {
+    return toScale.wadToRay().rayDiv(uint256(scaledAmount.scale)).rayToWad();
+  }
+
+  function scaleAmountNow(
+    ScaledAmount storage scaledAmount,
+    uint256 interestRate,
+    uint256 toScale
+  ) internal view returns (uint256) {
+    return toScale.wadToRay().rayDiv(getScale(scaledAmount, interestRate)).rayToWad();
+  }
+
+  function add(
+    ScaledAmount storage scaledAmount,
+    uint256 amount,
+    uint256 interestRate
+  ) internal returns (uint256) {
+    updateScale(scaledAmount, interestRate);
+    uint256 scaledAdd = scaleAmount(scaledAmount, amount);
+    scaledAmount.amount += scaledAdd.toUint96();
+    return scaledAdd;
+  }
+
+  function sub(
+    ScaledAmount storage scaledAmount,
+    uint256 amount,
+    uint256 interestRate
+  ) internal returns (uint256) {
+    updateScale(scaledAmount, interestRate);
+    uint256 scaledSub = scaleAmount(scaledAmount, amount);
+    scaledAmount.amount -= scaledSub.toUint96();
+    if (scaledAmount.amount == 0) {
+      // Reset scale if amount == 0
+      scaledAmount.scale = RAY112;
+    }
+    return scaledSub;
+  }
+
+  function discreteChange(
+    ScaledAmount storage scaledAmount,
+    int256 amount,
+    uint256 interestRate
+  ) internal {
+    updateScale(scaledAmount, interestRate);
+    uint256 newScaledAmount = uint256(int256(getScaledAmount(scaledAmount, interestRate)) + amount);
+    scaledAmount.scale = newScaledAmount
+      .wadToRay()
+      .rayDiv(uint256(scaledAmount.amount).wadToRay())
+      .toUint112();
+    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;
+  }
+}

package/contracts/TrustfulRiskModule.sol

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.0;
 
-import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
+import {IPremiumsAccount} from "./interfaces/IPremiumsAccount.sol";
 import {RiskModule} from "./RiskModule.sol";
 import {Policy} from "./Policy.sol";
 
@@ -19,61 +20,122 @@ contract TrustfulRiskModule is RiskModule {
 
   /// @custom:oz-upgrades-unsafe-allow constructor
   // solhint-disable-next-line no-empty-blocks
-  constructor(IPolicyPool policyPool_) RiskModule(policyPool_) {}
+  constructor(IPolicyPool policyPool_, IPremiumsAccount premiumsAccount_)
+    RiskModule(policyPool_, premiumsAccount_)
+  {} // solhint-disable-line no-empty-blocks
 
   /**
    * @dev Initializes the RiskModule
    * @param name_ Name of the Risk Module
-   * @param scrPercentage_ Solvency Capital Requirement percentage, to calculate
-                          capital requirement as % of (payout - premium)  (in ray)
-   * @param ensuroFee_ % of premium that will go for Ensuro treasury (in ray)
-   * @param scrInterestRate_ cost of capital (in ray)
-   * @param maxScrPerPolicy_ Max SCR to be allocated to this module (in wad)
-   * @param scrLimit_ Max SCR to be allocated to this module (in wad)
+   * @param collRatio_ Collateralization ratio to compute solvency requirement as % of payout (in ray)
+   * @param ensuroPpFee_ % of pure premium that will go for Ensuro treasury (in ray)
+   * @param srRoc_ return on capital paid to Senior LPs (annualized percentage - in ray)
+   * @param maxPayoutPerPolicy_ Maximum payout per policy (in wad)
+   * @param exposureLimit_ Max exposure (sum of payouts) to be allocated to this module (in wad)
    * @param wallet_ Address of the RiskModule provider
    */
   function initialize(
     string memory name_,
-    uint256 scrPercentage_,
-    uint256 ensuroFee_,
-    uint256 scrInterestRate_,
-    uint256 maxScrPerPolicy_,
-    uint256 scrLimit_,
+    uint256 collRatio_,
+    uint256 ensuroPpFee_,
+    uint256 srRoc_,
+    uint256 maxPayoutPerPolicy_,
+    uint256 exposureLimit_,
     address wallet_
   ) public initializer {
     __RiskModule_init(
       name_,
-      scrPercentage_,
-      ensuroFee_,
-      scrInterestRate_,
-      maxScrPerPolicy_,
-      scrLimit_,
+      collRatio_,
+      ensuroPpFee_,
+      srRoc_,
+      maxPayoutPerPolicy_,
+      exposureLimit_,
       wallet_
     );
   }
 
+  /**
+   * @dev Creates a new Policy
+   *
+   * Requirements:
+   * - The caller has been granted componentRole(PRICER_ROLE)
+   *
+   * Emits:
+   * - {PolicyPool.NewPolicy}
+   *
+   * @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 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
+   * @return Returns the id of the created policy
+   */
   function newPolicy(
     uint256 payout,
     uint256 premium,
     uint256 lossProb,
     uint40 expiration,
-    address customer,
+    address onBehalfOf,
     uint96 internalId
-  ) external onlyRole(PRICER_ROLE) returns (uint256) {
-    return _newPolicy(payout, premium, lossProb, expiration, customer, internalId).id;
+  ) external onlyComponentRole(PRICER_ROLE) returns (uint256) {
+    address payer = onBehalfOf;
+    if (payer != _msgSender() && _policyPool.currency().allowance(payer, _msgSender()) < premium)
+      /**
+       * The standard is the payer should be the _msgSender() but usually, in this type of module,
+       * the sender is an operative account managed by software, where the onBehalfOf is a more
+       * secure account (hardware wallet) that does the cash movements.
+       * This non standard behaviour allows for a more secure setup, where the sender never manages
+       * cash.
+       * We leverage the currency's allowance mechanism to allow the sender access to the payer's
+       * funds.
+       * Note that this allowance won't be spent, so it can be set as the maximum amount of a single
+       * premium even for multiple policies.
+       */
+      payer = _msgSender();
+
+    return _newPolicy(payout, premium, lossProb, expiration, payer, onBehalfOf, internalId).id;
   }
 
+  /**
+   * @dev Resolves a policy, if payout > 0, it pays to the policy holder.
+   *
+   * Requirements:
+   * - The caller has been granted componentRole(RESOLVER_ROLE)
+   * - payout <= policy.payout
+   * - block.timestamp >= policy.expiration
+   *
+   * Emits:
+   * - {PolicyPool.PolicyResolved}
+   *
+   * @param policy The policy previously created (from {NewPolicy} event)
+   * @param payout The payout to transfer to the policy holder
+   */
   function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout)
     external
-    onlyRole(RESOLVER_ROLE)
+    onlyComponentRole(RESOLVER_ROLE)
     whenNotPaused
   {
     _policyPool.resolvePolicy(policy, payout);
   }
 
+  /**
+   * @dev Resolves a policy with full payout (policy.payout) if customerWon == true
+   *
+   * Requirements:
+   * - The caller has been granted componentRole(RESOLVER_ROLE)
+   * - block.timestamp >= policy.expiration
+   *
+   * Emits:
+   * - {PolicyPool.PolicyResolved}
+   *
+   * @param policy The policy previously created (from {NewPolicy} event)
+   * @param customerWon If true, policy.payout is transferred to the policy holder. If false, the policy is resolved
+   * without payout and can't be longer claimed.
+   */
   function resolvePolicyFullPayout(Policy.PolicyData calldata policy, bool customerWon)
     external
-    onlyRole(RESOLVER_ROLE)
+    onlyComponentRole(RESOLVER_ROLE)
     whenNotPaused
   {
     _policyPool.resolvePolicyFullPayout(policy, customerWon);

package/contracts/dependencies/ERC1967Proxy.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/*
+This is a workaround for:
+
+https://github.com/eth-brownie/brownie/issues/1581
+
+Which affects ethproto. The contract is just here for ethproto's
+sake and is not actually used by any contract.
+
+Once that bug is fixed (either in brownie or in ethproto) this
+file can be safely removed.
+
+*/
+
+import {ERC1967Proxy as ERC1967ProxyOriginal} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+
+abstract contract ERC1967Proxy is ERC1967ProxyOriginal {}

package/contracts/dependencies/IERC20Metadata.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/*
+This is a workaround for:
+
+https://github.com/eth-brownie/brownie/issues/1581
+
+Which affects ethproto. The contract is just here for ethproto's
+sake and is not actually used by any contract.
+
+Once that bug is fixed (either in brownie or in ethproto) this
+file can be safely removed.
+
+*/
+
+import {IERC20Metadata as IERC20MetadataOriginal} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+interface IERC20Metadata is IERC20MetadataOriginal {}

package/contracts/dependencies/WadRayMath.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+/**
+ * @title WadRayMath library
+ * @author Aave
+ * @notice Provides functions to perform calculations with Wad and Ray units
+ * @dev Provides mul and div function for wads (decimal numbers with 18 digits of precision) and rays (decimal numbers
+ * with 27 digits of precision)
+ * @dev Operations are rounded. If a value is >=.5, will be rounded up, otherwise rounded down.
+ **/
+library WadRayMath {
+  // HALF_WAD and HALF_RAY expressed with extended notation as constant with operations are not supported in Yul assembly
+  uint256 internal constant WAD = 1e18;
+  uint256 internal constant HALF_WAD = 0.5e18;
+
+  uint256 internal constant RAY = 1e27;
+  uint256 internal constant HALF_RAY = 0.5e27;
+
+  uint256 internal constant WAD_RAY_RATIO = 1e9;
+
+  /**
+   * @dev Multiplies two wad, rounding half up to the nearest wad
+   * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+   * @param a Wad
+   * @param b Wad
+   * @return c = a*b, in wad
+   **/
+  function wadMul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    // to avoid overflow, a <= (type(uint256).max - HALF_WAD) / b
+    assembly {
+      if iszero(or(iszero(b), iszero(gt(a, div(sub(not(0), HALF_WAD), b))))) {
+        revert(0, 0)
+      }
+
+      c := div(add(mul(a, b), HALF_WAD), WAD)
+    }
+  }
+
+  /**
+   * @dev Divides two wad, rounding half up to the nearest wad
+   * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+   * @param a Wad
+   * @param b Wad
+   * @return c = a/b, in wad
+   **/
+  function wadDiv(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    // to avoid overflow, a <= (type(uint256).max - halfB) / WAD
+    assembly {
+      if or(iszero(b), iszero(iszero(gt(a, div(sub(not(0), div(b, 2)), WAD))))) {
+        revert(0, 0)
+      }
+
+      c := div(add(mul(a, WAD), div(b, 2)), b)
+    }
+  }
+
+  /**
+   * @notice Multiplies two ray, rounding half up to the nearest ray
+   * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+   * @param a Ray
+   * @param b Ray
+   * @return c = a raymul b
+   **/
+  function rayMul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    // to avoid overflow, a <= (type(uint256).max - HALF_RAY) / b
+    assembly {
+      if iszero(or(iszero(b), iszero(gt(a, div(sub(not(0), HALF_RAY), b))))) {
+        revert(0, 0)
+      }
+
+      c := div(add(mul(a, b), HALF_RAY), RAY)
+    }
+  }
+
+  /**
+   * @notice Divides two ray, rounding half up to the nearest ray
+   * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+   * @param a Ray
+   * @param b Ray
+   * @return c = a raydiv b
+   **/
+  function rayDiv(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    // to avoid overflow, a <= (type(uint256).max - halfB) / RAY
+    assembly {
+      if or(iszero(b), iszero(iszero(gt(a, div(sub(not(0), div(b, 2)), RAY))))) {
+        revert(0, 0)
+      }
+
+      c := div(add(mul(a, RAY), div(b, 2)), b)
+    }
+  }
+
+  /**
+   * @dev Casts ray down to wad
+   * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+   * @param a Ray
+   * @return b = a converted to wad, rounded half up to the nearest wad
+   **/
+  function rayToWad(uint256 a) internal pure returns (uint256 b) {
+    assembly {
+      b := div(a, WAD_RAY_RATIO)
+      let remainder := mod(a, WAD_RAY_RATIO)
+      if iszero(lt(remainder, div(WAD_RAY_RATIO, 2))) {
+        b := add(b, 1)
+      }
+    }
+  }
+
+  /**
+   * @dev Converts wad up to ray
+   * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+   * @param a Wad
+   * @return b = a converted in ray
+   **/
+  function wadToRay(uint256 a) internal pure returns (uint256 b) {
+    // to avoid overflow, b/WAD_RAY_RATIO == a
+    assembly {
+      b := mul(a, WAD_RAY_RATIO)
+
+      if iszero(eq(div(b, WAD_RAY_RATIO), a)) {
+        revert(0, 0)
+      }
+    }
+  }
+}