@ensuro/core 2.5.0 → 2.6.0

package/contracts/SignedBucketRiskModule.sol

@@ -0,0 +1,451 @@
+// 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). One of the components of the price it's a bucket id that groups policies within
+        a risk module, with different parameters (such as collaterallization levels or fees).
+        For the resolution (resolvePolicy), it has to be called by an authorized user
+  * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+contract SignedBucketRiskModule 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;
+
+  mapping(uint256 => PackedParams) internal _buckets;
+
+  /**
+   * @dev Emitted when a new risk bucket is created (or modified).
+   * @param bucketId The identifier of the group of policies.
+   * @param params The packed parameters of the new bucket.
+   */
+  event NewBucket(uint256 indexed bucketId, Params params);
+
+  /**
+   * @dev Emitted when a risk bucket is deleted.
+   * @param bucketId The identifier of the group of policies.
+   */
+  event BucketDeleted(uint256 indexed bucketId);
+
+  /**
+   * @dev Event emitted every time a new policy is created. It allows to link the policyData with a particular policy
+   *
+   * @param policyId The id of the policy
+   * @param policyData The value sent in `policyData` parameter that's the hash of the off-chain stored data.
+   */
+  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 _checkSignature(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    bytes32 policyData,
+    uint256 bucketId,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil
+  ) internal view {
+    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,
+        bucketId,
+        quoteValidUntil
+      )
+    );
+    address signer = ECDSA.recover(quoteHash, quoteSignatureR, quoteSignatureVS);
+    _policyPool.access().checkComponentRole(address(this), PRICER_ROLE, signer, false);
+  }
+
+  function _newPolicySigned(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    bytes32 policyData,
+    uint256 bucketId,
+    address payer,
+    address onBehalfOf
+  ) internal returns (Policy.PolicyData memory createdPolicy) {
+    uint96 internalId = uint96(uint256(policyData) % 2**96);
+    createdPolicy = _newPolicyWithParams(
+      payout,
+      premium,
+      lossProb,
+      expiration,
+      payer,
+      onBehalfOf,
+      internalId,
+      bucketParams(bucketId)
+    );
+    emit NewSignedPolicy(createdPolicy.id, policyData);
+    return createdPolicy;
+  }
+
+  /**
+   * @dev Creates a new Policy using a signed quote. The caller is the payer of the policy. Returns all the struct, not just the id.
+   *
+   * 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 bucketId Identifies the group to which the policy belongs (that defines the RM parameters applicable to it)
+   * @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 newPolicyFull(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    address onBehalfOf,
+    bytes32 policyData,
+    uint256 bucketId,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil
+  ) external whenNotPaused returns (Policy.PolicyData memory createdPolicy) {
+    _checkSignature(
+      payout,
+      premium,
+      lossProb,
+      expiration,
+      policyData,
+      bucketId,
+      quoteSignatureR,
+      quoteSignatureVS,
+      quoteValidUntil
+    );
+    return
+      _newPolicySigned(
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        policyData,
+        bucketId,
+        _msgSender(),
+        onBehalfOf
+      );
+  }
+
+  /**
+   * @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 bucketId Identifies the group to which the policy belongs (that defines the RM parameters applicable to it)
+   * @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,
+    uint256 bucketId,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil
+  ) external whenNotPaused returns (uint256) {
+    _checkSignature(
+      payout,
+      premium,
+      lossProb,
+      expiration,
+      policyData,
+      bucketId,
+      quoteSignatureR,
+      quoteSignatureVS,
+      quoteValidUntil
+    );
+    return
+      _newPolicySigned(
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        policyData,
+        bucketId,
+        _msgSender(),
+        onBehalfOf
+      ).id;
+  }
+
+  /**
+   * @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 bucketId Identifies the group to which the policy belongs (that defines the RM parameters applicable to it)
+   * @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,
+    uint256 bucketId,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil
+  ) external whenNotPaused 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.
+     */
+    _checkSignature(
+      payout,
+      premium,
+      lossProb,
+      expiration,
+      policyData,
+      bucketId,
+      quoteSignatureR,
+      quoteSignatureVS,
+      quoteValidUntil
+    );
+    return
+      _newPolicySigned(
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        policyData,
+        bucketId,
+        onBehalfOf,
+        onBehalfOf
+      ).id;
+  }
+
+  function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout)
+    external
+    onlyComponentRole(RESOLVER_ROLE)
+    whenNotPaused
+  {
+    _policyPool.resolvePolicy(policy, payout);
+  }
+
+  /**
+   * @dev Sets the parameters for a risk bucket.
+   *
+   * Requirements:
+   *
+   * - The caller must have the LEVEL1_ROLE or LEVEL2_ROLE
+   *
+   * @param bucketId Group identifier for the policies that will have these parameters
+   * @param params_ The parameters of the new bucket.
+   */
+  function setBucketParams(uint256 bucketId, Params calldata params_)
+    external
+    onlyGlobalOrComponentRole2(LEVEL1_ROLE, LEVEL2_ROLE)
+  {
+    require(
+      bucketId != 0,
+      "SignedBucketRiskModule: bucketId can't be zero, set default RM parameters"
+    );
+    _buckets[bucketId] = 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
+    });
+    _validatePackedParams(_buckets[bucketId]);
+    emit NewBucket(bucketId, params_);
+  }
+
+  /**
+   * @dev Deletes a bucket
+   *
+   * Requirements:
+   *
+   * - The caller must have the LEVEL1_ROLE or LEVEL2_ROLE
+   *
+   * @param bucketId Group identifier for the policies that will have these parameters
+   */
+  function deleteBucket(uint256 bucketId)
+    external
+    onlyGlobalOrComponentRole2(LEVEL1_ROLE, LEVEL2_ROLE)
+  {
+    require(
+      bucketId != 0,
+      "SignedBucketRiskModule: bucketId can't be zero, set default RM parameters"
+    );
+    delete _buckets[bucketId];
+    emit BucketDeleted(bucketId);
+  }
+
+  /**
+   * @dev returns the risk bucket parameters for the given bucketId
+   *
+   * @param bucketId Id of the bucket of 0 if you want the default params
+   */
+  function bucketParams(uint256 bucketId) public view returns (Params memory params_) {
+    if (bucketId != 0) {
+      PackedParams storage bucketParams_ = _buckets[bucketId];
+      require(bucketParams_.moc != 0, "SignedBucketRiskModule: bucket not found!");
+      params_ = _unpackParams(bucketParams_);
+    } else {
+      params_ = params();
+    }
+  }
+
+  /**
+   * @dev Returns the minimum premium for a given bucket
+   *
+   * @param payout Maximum payout of the policy
+   * @param lossProb Probability of having a loss equal to the maximum payout
+   * @param expiration Expiration date of the policy
+   * @param bucketId Id of the bucket of 0 if you want the default params
+   */
+  function getMinimumPremiumForBucket(
+    uint256 payout,
+    uint256 lossProb,
+    uint40 expiration,
+    uint256 bucketId
+  ) public view virtual returns (uint256) {
+    return _getMinimumPremium(payout, lossProb, expiration, bucketParams(bucketId));
+  }
+
+  /**
+   * @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;
+}

package/js/constants.js

@@ -0,0 +1,7 @@
+const WEEK = 3600 * 24 * 7;
+const DAY = 3600 * 24;
+
+module.exports = {
+  WEEK,
+  DAY,
+};

package/js/deploy.js

@@ -3,45 +3,14 @@ const helpers = require("@nomicfoundation/hardhat-network-helpers");
 const fs = require("fs");
 const { request } = require("undici");
 const ethers = require("ethers");
-
-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,
-};
+const { task, types } = require("hardhat/config");
+const { WhitelistStatus } = require("../js/enums");
+const { amountFunction, _W, grantRole, grantComponentRole, getDefaultSigner } = require("../js/utils");
 
 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.
- * @returns The amount function created. The function can receive strings (recommended),
- *          floats/doubles (not recommended) and integers.
- *
- *          Floats will be rounded to 6 decimal before scaling.
- */
-function amountFunction(decimals) {
-  return function (value) {
-    if (value === undefined) return undefined;
-
-    if (typeof value === "string" || value instanceof String) {
-      return hre.ethers.utils.parseUnits(value, decimals);
-    }
-
-    if (!Number.isInteger(value)) {
-      return _BN(Math.round(value * 1e6)).mul(_BN(Math.pow(10, decimals - 6)));
-    }
-
-    return _BN(value).mul(_BN(10).pow(decimals));
-  };
-}
-
 function amountDecimals() {
   let decimals = Number.parseInt(process.env.DEPLOY_AMOUNT_DECIMALS);
   console.assert(decimals >= 6);
@@ -49,8 +18,6 @@ function amountDecimals() {
 }
 
 const GWei = amountFunction(9);
-const _W = amountFunction(18);
-const _R = amountFunction(27);
 const _A = amountFunction(amountDecimals());
 
 /**
@@ -185,48 +152,6 @@ async function deployProxyContract(
   return { ContractFactory, contract };
 }
 
-function parseRole(role) {
-  if (role.startsWith("0x")) return role;
-  if (role === "DEFAULT_ADMIN_ROLE") return ethers.constants.HashZero;
-  return ethers.utils.keccak256(ethers.utils.toUtf8Bytes(role));
-}
-
-async function grantComponentRole(hre, contract, component, role, user) {
-  let userAddress;
-  if (user === undefined) {
-    user = await _getDefaultSigner(hre);
-    userAddress = user.address;
-  } else {
-    userAddress = user;
-  }
-  const roleHex = parseRole(role);
-  const componentAddress = component.address || component;
-  const componentRole = await contract.getComponentRole(componentAddress, roleHex);
-  if (!(await contract.hasRole(componentRole, userAddress))) {
-    await contract.grantComponentRole(componentAddress, roleHex, userAddress, txOverrides());
-    console.log(`Role ${role} (${roleHex}) Component ${componentAddress} granted to ${userAddress}`);
-  } else {
-    console.log(`Role ${role} (${roleHex}) Component ${componentAddress} already granted to ${userAddress}`);
-  }
-}
-
-async function grantRole(hre, contract, role, user) {
-  let userAddress;
-  if (user === undefined) {
-    user = await _getDefaultSigner(hre);
-    userAddress = user.address;
-  } else {
-    userAddress = user;
-  }
-  const roleHex = parseRole(role);
-  if (!(await contract.hasRole(roleHex, userAddress))) {
-    await contract.grantRole(roleHex, userAddress, txOverrides());
-    console.log(`Role ${role} (${roleHex}) granted to ${userAddress}`);
-  } else {
-    console.log(`Role ${role} (${roleHex}) already granted to ${userAddress}`);
-  }
-}
-
 async function grantRoleTask({ contractAddress, role, account, component, impersonate, impersonateBalance }, hre) {
   let contract = await hre.ethers.getContractAt("AccessManager", contractAddress);
   if (impersonate !== undefined) {
@@ -237,9 +162,9 @@ async function grantRoleTask({ contractAddress, role, account, component, impers
     contract = contract.connect(signer);
   }
   if (component === ethers.constants.AddressZero) {
-    await grantRole(hre, contract, role, account);
+    await grantRole(hre, contract, role, account, txOverrides(), console.log);
   } else {
-    await grantComponentRole(hre, contract, component, role, account);
+    await grantComponentRole(hre, contract, component, role, account, txOverrides(), console.log);
   }
 }
 
@@ -260,11 +185,6 @@ async function deployAccessManager(opts, hre) {
   return (await deployProxyContract({ contractClass: "AccessManager", ...opts }, hre)).contract.address;
 }
 
-async function _getDefaultSigner(hre) {
-  const signers = await hre.ethers.getSigners();
-  return signers[0];
-}
-
 async function deployPolicyPool({ accessAddress, currencyAddress, nftName, nftSymbol, treasuryAddress, ...opts }, hre) {
   return (
     await deployProxyContract(
@@ -447,7 +367,7 @@ async function deployAaveAssetManager({ asset, aave, amClass, ...opts }, hre) {
 }
 
 async function deployWhitelist(
-  { wlClass, poolAddress, extraConstructorArgs, extraArgs, eToken, eToken2, eToken3, defaultStatus, runAs, ...opts },
+  { wlClass, poolAddress, extraConstructorArgs, extraArgs, eToken, eToken2, eToken3, defaultStatus, ...opts },
   hre
 ) {
   extraArgs = extraArgs || [];
@@ -490,7 +410,7 @@ async function trustfullPolicy({ rmAddress, payout, premium, lossProb, expiratio
   const currency = await hre.ethers.getContractAt("IERC20Metadata", await policyPool.currency());
   await grantComponentRole(hre, access, rm, "PRICER_ROLE");
 
-  customer = customer || (await _getDefaultSigner(hre));
+  customer = customer || (await getDefaultSigner(hre));
   premium = _A(premium);
 
   await currency.approve(policyPool.address, premium);
@@ -534,7 +454,7 @@ async function flightDelayPolicy(
   const currency = await hre.ethers.getContractAt("IERC20Metadata", await policyPool.currency());
 
   await grantComponentRole(hre, access, rm, "PRICER_ROLE");
-  customer = customer || (await _getDefaultSigner(hre));
+  customer = customer || (await getDefaultSigner(hre));
   premium = _A(premium);
 
   await currency.approve(policyPool.address, premium);
@@ -561,7 +481,7 @@ async function listETokens({ poolAddress }, hre) {
 
   console.log(`Pool has ${etkCount} tokens`);
 
-  for (i = 0; i < etkCount; i++) {
+  for (let i = 0; i < etkCount; i++) {
     const etk = await hre.ethers.getContractAt("EToken", await policyPool.getETokenAt(i));
     const etkName = await etk.name();
     console.log(`eToken at ${etk.address}: ${etkName}`);
@@ -599,7 +519,7 @@ function add_task() {
         taskArgs.accessAddress = await deployAccessManager(taskArgs, hre);
       }
       taskArgs.saveAddr = "POOL";
-      let policyPoolAddress = await deployPolicyPool(taskArgs, hre);
+      await deployPolicyPool(taskArgs, hre);
     });
 
   task("deploy:testCurrency", "Deploys the Test Currency")
@@ -786,15 +706,12 @@ module.exports = {
   logContractCreated,
   deployContract,
   deployProxyContract,
-  grantRole,
-  grantComponentRole,
   deployEToken,
   deployPremiumsAccount,
   deployRiskModule,
   deploySignedQuoteRM,
   setAssetManager,
   deployWhitelist,
-  WhitelistStatus,
   txOverrides,
   amountFunction,
   _W,

package/js/enums.js

@@ -0,0 +1,30 @@
+const WhitelistStatus = {
+  notdefined: 0,
+  whitelisted: 1,
+  blacklisted: 2,
+};
+
+const RiskModuleParameter = {
+  moc: 0,
+  jrCollRatio: 1,
+  collRatio: 2,
+  ensuroPpFee: 3,
+  ensuroCocFee: 4,
+  jrRoc: 5,
+  srRoc: 6,
+  maxPayoutPerPolicy: 7,
+  exposureLimit: 8,
+  maxDuration: 9,
+};
+
+const ComponentKind = {
+  eToken: 1,
+  riskModule: 2,
+  premiumsAccount: 3,
+};
+
+module.exports = {
+  WhitelistStatus,
+  RiskModuleParameter,
+  ComponentKind,
+};