@ensuro/core 2.5.0 → 2.6.0-beta1

package/js/test-utils.js

@@ -1,12 +1,6 @@
-const { expect } = require("chai");
 const hre = require("hardhat");
-const { BigNumber } = require("ethers");
-const { LogDescription } = require("ethers/lib/utils");
-const { findAll } = require("solidity-ast/utils");
-const helpers = require("@nomicfoundation/hardhat-network-helpers");
-
-WEEK = 3600 * 24 * 7;
-DAY = 3600 * 24;
+const { _W, grantRole, getTransactionEvent } = require("../js/utils");
+const { RiskModuleParameter } = require("../js/enums");
 
 async function initCurrency(options, initial_targets, initial_balances) {
   const Currency = await hre.ethers.getContractFactory("TestCurrency");
@@ -25,36 +19,7 @@ async function initCurrency(options, initial_targets, initial_balances) {
   return currency;
 }
 
-async function approve_multiple(currency, spender, sources, amounts) {
-  return Promise.all(
-    sources.map(async function (source, index) {
-      await currency.connect(source).approve(spender.address, amounts[index]);
-    })
-  );
-}
-
-async function check_balances(currency, users, amounts) {
-  return Promise.all(
-    users.map(async function (user, index) {
-      expect(await currency.balanceOf(user.address)).to.equal(amounts[index]);
-    })
-  );
-}
-
-const RiskModuleParameter = {
-  moc: 0,
-  jrCollRatio: 1,
-  collRatio: 2,
-  ensuroPpFee: 3,
-  ensuroCocFee: 4,
-  jrRoc: 5,
-  srRoc: 6,
-  maxPayoutPerPolicy: 7,
-  exposureLimit: 8,
-  maxDuration: 9,
-};
-
-const createRiskModule = async function (
+async function createRiskModule(
   pool,
   premiumsAccount,
   contractFactory,
@@ -99,7 +64,7 @@ const createRiskModule = async function (
     await rm.setParam(RiskModuleParameter.moc, moc);
   }
   return rm;
-};
+}
 
 async function addRiskModule(
   pool,
@@ -135,7 +100,7 @@ async function addRiskModule(
   return rm;
 }
 
-const createEToken = async function (
+async function createEToken(
   pool,
   { etkName, etkSymbol, maxUtilizationRate, poolLoanInterestRate, extraArgs, extraConstructorArgs }
 ) {
@@ -160,9 +125,9 @@ const createEToken = async function (
 
   await etk.deployed();
   return etk;
-};
+}
 
-addEToken = async function addEToken(
+async function addEToken(
   pool,
   { etkName, etkSymbol, maxUtilizationRate, poolLoanInterestRate, extraArgs, extraConstructorArgs }
 ) {
@@ -176,42 +141,12 @@ addEToken = async function addEToken(
   });
   await pool.addComponent(etk.address, 1);
   return etk;
-};
-
-async function expected_change(protocol_attribute, initial, change) {
-  change = BigNumber.from(change);
-  let actual_value = await protocol_attribute();
-  expect(actual_value.sub(initial)).to.equal(change);
-  return actual_value;
 }
 
-/**
- * Finds an event in the receipt
- * @param {Interface} interface The interface of the contract that contains the requested event
- * @param {TransactionReceipt} receipt Transaction receipt containing the events in the logs
- * @param {String} eventName The name of the event we are interested in
- * @returns {LogDescription}
- */
-const getTransactionEvent = function (interface, receipt, eventName) {
-  // for each log in the transaction receipt
-  for (const log of receipt.logs) {
-    let parsedLog;
-    try {
-      parsedLog = interface.parseLog(log);
-    } catch (error) {
-      continue;
-    }
-    if (parsedLog.name == eventName) {
-      return parsedLog;
-    }
-  }
-  return null; // not found
-};
-
 const randomAddress = "0x89cDb70Fee571251a66E34caa1673cE40f7549Dc";
 
 /**
- * Deploys de PolicyPool contract and AccessManager
+ * Deploys the PolicyPool contract and AccessManager
  *
  * By default deployes de PolicyPool and AccessManager and grants LEVEL 1, 2, 3 permissions
  *
@@ -224,7 +159,7 @@ const randomAddress = "0x89cDb70Fee571251a66E34caa1673cE40f7549Dc";
  * - .grantRoles: default []. List of additional roles to grant
  * - .dontGrantL123Roles: if specified, doesn't grants LEVEL1, 2 and 3 roles.
  */
-async function deployPool(hre, options) {
+async function deployPool(options) {
   const PolicyPool = await hre.ethers.getContractFactory("PolicyPool");
   const AccessManager = await hre.ethers.getContractFactory("AccessManager");
 
@@ -266,7 +201,7 @@ async function deployPool(hre, options) {
   return policyPool;
 }
 
-async function deployPremiumsAccount(hre, pool, options, addToPool = true) {
+async function deployPremiumsAccount(pool, options, addToPool = true) {
   const PremiumsAccount = await hre.ethers.getContractFactory("PremiumsAccount");
   const premiumsAccount = await hre.upgrades.deployProxy(PremiumsAccount, [], {
     constructorArgs: [
@@ -285,112 +220,6 @@ async function deployPremiumsAccount(hre, pool, options, addToPool = true) {
   return premiumsAccount;
 }
 
-async function _getDefaultSigner(hre) {
-  const signers = await hre.ethers.getSigners();
-  return signers[0];
-}
-
-async function grantRole(hre, contract, role, user) {
-  let userAddress;
-  if (user === undefined) {
-    user = await _getDefaultSigner(hre);
-    userAddress = user.address;
-  } else {
-    userAddress = user;
-  }
-  if (!(await contract.hasRole(getRole(role), userAddress))) {
-    await contract.grantRole(getRole(role), userAddress);
-  }
-}
-
-async function grantComponentRole(hre, accessManager, component, role, user) {
-  let userAddress;
-  if (user === undefined) {
-    user = await _getDefaultSigner(hre);
-    userAddress = user.address;
-  } else {
-    userAddress = user.address === undefined ? user : user.address;
-  }
-  const componentRole = getComponentRole(component.address, getRole(role));
-  if (!(await accessManager.hasRole(componentRole, userAddress))) {
-    await accessManager.grantComponentRole(component.address, getRole(role), userAddress);
-  }
-}
-
-const _E = hre.ethers.utils.parseEther;
-
-const _BN = hre.ethers.BigNumber.from;
-
-const WAD = _BN(10).pow(18); // 1e18
-
-const RAY = _BN(10).pow(27); // 1e27
-
-/**
- * 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));
-  };
-}
-
-const _W = amountFunction(18);
-
-const _R = amountFunction(27);
-
-/**
- * Builds the component role identifier
- *
- * Mimics the behaviour of the PolicyPoolConfig.getComponentRole method
- *
- * Component roles are roles created doing XOR between the component
- * address and the original role.
- *
- * Example:
- *     getComponentRole("0xc6e7DF5E7b4f2A278906862b61205850344D4e7d", "ORACLE_ADMIN_ROLE")
- *     // "0x05e01b185238b49f750d03d945e38a7f6c3be8b54de0ee42d481eb7814f0d3a8"
- */
-function getComponentRole(componentAddress, role) {
-  if (!role.startsWith("0x")) role = getRole(role);
-
-  // 32 byte array
-  const bytesRole = hre.ethers.utils.arrayify(role);
-
-  // 20 byte array
-  const bytesAddress = hre.ethers.utils.arrayify(componentAddress);
-
-  // xor each byte, padding bytesAddress with zeros at the end
-  return hre.ethers.utils.hexlify(bytesRole.map((elem, idx) => elem ^ (bytesAddress[idx] || 0)));
-}
-
-/*
-Builds AccessControl error message for comparison in tests
-*/
-function accessControlMessage(address, component, role) {
-  const roleHash = component !== null ? getComponentRole(component, role) : getRole(role);
-
-  return `AccessControl: account ${address.toLowerCase()} is missing role ${roleHash}`;
-}
-
-function makePolicyId(rm, internalId) {
-  return hre.ethers.BigNumber.from(rm.address).shl(96).add(internalId);
-}
-
 async function makePolicy(pool, rm, cust, payout, premium, lossProb, expiration, internalId, method = "newPolicy") {
   let tx = await rm.connect(cust)[method](payout, premium, lossProb, expiration, cust.address, internalId);
   let receipt = await tx.wait();
@@ -399,71 +228,15 @@ async function makePolicy(pool, rm, cust, payout, premium, lossProb, expiration,
   return newPolicyEvt;
 }
 
-function getRole(role) {
-  return role === "DEFAULT_ADMIN_ROLE"
-    ? "0x0000000000000000000000000000000000000000000000000000000000000000"
-    : hre.ethers.utils.keccak256(hre.ethers.utils.toUtf8Bytes(role));
-}
-
-async function getStorageLayout(contractSrc, contractName) {
-  const buildInfo = await hre.artifacts.getBuildInfo(`${contractSrc}:${contractName}`);
-  if (buildInfo === undefined) throw new Error(`Contract ${contractSrc}:${contractName} not in artifacts`);
-
-  const solcOutput = buildInfo.output;
-
-  const storageLayouts = {};
-
-  for (const def of findAll("ContractDefinition", solcOutput.sources[contractSrc].ast)) {
-    storageLayouts[def.name] = solcOutput.contracts[contractSrc][def.name].storageLayout;
-  }
-
-  return storageLayouts[contractName];
-}
-
-function makeQuoteMessage({ rmAddress, payout, premium, lossProb, expiration, policyData, validUntil }) {
-  return ethers.utils.solidityPack(
-    ["address", "uint256", "uint256", "uint256", "uint40", "bytes32", "uint40"],
-    [rmAddress, payout, premium, lossProb, expiration, policyData, validUntil]
-  );
-}
-
-async function makeSignedQuote(signer, policyParams) {
-  const quoteMessage = makeQuoteMessage(policyParams);
-  return ethers.utils.splitSignature(await signer.signMessage(ethers.utils.arrayify(quoteMessage)));
-}
-
 if (process.env.ENABLE_HH_WARNINGS !== "yes") hre.upgrades.silenceWarnings();
 
 module.exports = {
-  _BN,
-  _E,
-  _R,
-  _W,
-  accessControlMessage,
   addEToken,
   addRiskModule,
-  amountFunction,
-  approve_multiple,
-  check_balances,
   createEToken,
   createRiskModule,
-  DAY,
   deployPool,
   deployPremiumsAccount,
-  expected_change,
-  getComponentRole,
-  getRole,
-  getStorageLayout,
-  getTransactionEvent,
-  grantComponentRole,
-  grantRole,
   initCurrency,
   makePolicy,
-  makePolicyId,
-  makeQuoteMessage,
-  makeSignedQuote,
-  RAY,
-  RiskModuleParameter,
-  WAD,
-  WEEK,
 };

package/js/utils.js

@@ -0,0 +1,264 @@
+const { findAll } = require("solidity-ast/utils");
+const ethers = require("ethers");
+const helpers = require("@nomicfoundation/hardhat-network-helpers");
+
+const _E = ethers.utils.parseEther;
+const _BN = ethers.BigNumber.from;
+const WAD = _BN(10).pow(18); // 1e18
+const RAY = _BN(10).pow(27); // 1e27
+
+async function getStorageLayout(contractSrc, contractName, hre) {
+  const buildInfo = await hre.artifacts.getBuildInfo(`${contractSrc}:${contractName}`);
+  if (buildInfo === undefined) throw new Error(`Contract ${contractSrc}:${contractName} not in artifacts`);
+
+  const solcOutput = buildInfo.output;
+
+  const storageLayouts = {};
+
+  for (const def of findAll("ContractDefinition", solcOutput.sources[contractSrc].ast)) {
+    storageLayouts[def.name] = solcOutput.contracts[contractSrc][def.name].storageLayout;
+  }
+
+  return storageLayouts[contractName];
+}
+
+/**
+ * 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 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));
+  };
+}
+
+/** Wad function */
+const _W = amountFunction(18);
+
+/** Ray function */
+const _R = amountFunction(27);
+
+/**
+ * Returns a role identifier by computing the keccak of the role name.
+ */
+function getRole(role) {
+  if (role.startsWith("0x")) return role;
+  return role === "DEFAULT_ADMIN_ROLE"
+    ? ethers.constants.HashZero
+    : ethers.utils.keccak256(ethers.utils.toUtf8Bytes(role));
+}
+
+/**
+ * Builds the component role identifier
+ *
+ * Mimics the behaviour of the AccessManager.getComponentRole method
+ *
+ * Component roles are roles created doing XOR between the component
+ * address and the original role.
+ *
+ * Example:
+ *     getComponentRole("0xc6e7DF5E7b4f2A278906862b61205850344D4e7d", "ORACLE_ADMIN_ROLE")
+ *     // "0x05e01b185238b49f750d03d945e38a7f6c3be8b54de0ee42d481eb7814f0d3a8"
+ */
+function getComponentRole(componentAddress, role) {
+  if (!role.startsWith("0x")) role = getRole(role);
+
+  // 32 byte array
+  const bytesRole = ethers.utils.arrayify(role);
+
+  // 20 byte array
+  const bytesAddress = ethers.utils.arrayify(componentAddress);
+
+  // xor each byte, padding bytesAddress with zeros at the end
+  // eslint-disable-next-line no-bitwise
+  return ethers.utils.hexlify(bytesRole.map((elem, idx) => elem ^ (bytesAddress[idx] || 0)));
+}
+
+async function getDefaultSigner(hre) {
+  const signers = await hre.ethers.getSigners();
+  return signers[0];
+}
+
+/**
+ * Grant a component role to a user.
+ */
+// eslint-disable-next-line no-empty-function
+async function grantComponentRole(hre, contract, component, role, user, txOverrides = {}, log = () => {}) {
+  let userAddress;
+  if (user === undefined) {
+    user = await getDefaultSigner(hre);
+    userAddress = user.address;
+  } else {
+    userAddress = user.address === undefined ? user : user.address;
+  }
+  const roleHex = getRole(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);
+    log(`Role ${role} (${roleHex}) Component ${componentAddress} granted to ${userAddress}`);
+  } else {
+    log(`Role ${role} (${roleHex}) Component ${componentAddress} already granted to ${userAddress}`);
+  }
+}
+
+/**
+ * Grant a role to a user
+ */
+// eslint-disable-next-line no-empty-function
+async function grantRole(hre, contract, role, user, txOverrides = {}, log = () => {}) {
+  let userAddress;
+  if (user === undefined) {
+    user = await getDefaultSigner(hre);
+    userAddress = user.address;
+  } else {
+    userAddress = user.address === undefined ? user : user.address;
+  }
+  const roleHex = getRole(role);
+  if (!(await contract.hasRole(roleHex, userAddress))) {
+    await contract.grantRole(roleHex, userAddress, txOverrides);
+    log(`Role ${role} (${roleHex}) granted to ${userAddress}`);
+  } else {
+    log(`Role ${role} (${roleHex}) already granted to ${userAddress}`);
+  }
+}
+
+/**
+ * Finds an event in the receipt
+ * @param {Interface} interface The interface of the contract that contains the requested event
+ * @param {TransactionReceipt} receipt Transaction receipt containing the events in the logs
+ * @param {String} eventName The name of the event we are interested in
+ * @returns {LogDescription}
+ */
+function getTransactionEvent(interface, receipt, eventName) {
+  // for each log in the transaction receipt
+  for (const log of receipt.logs) {
+    let parsedLog;
+    try {
+      parsedLog = interface.parseLog(log);
+    } catch (error) {
+      continue;
+    }
+    if (parsedLog.name == eventName) {
+      return parsedLog;
+    }
+  }
+  return null; // not found
+}
+
+/**
+ * Builds AccessControl error message for comparison in tests
+ */
+function accessControlMessage(address, component, role) {
+  const roleHash = component !== null ? getComponentRole(component, role) : getRole(role);
+
+  return `AccessControl: account ${address.toLowerCase()} is missing role ${roleHash}`;
+}
+
+/**
+ * Create a policy id by combining the riskmodule address and the internal id.
+ *
+ * Mimics the PolicyPool.newPolicy method of building the policy id.
+ */
+function makePolicyId(rmAddress, internalId) {
+  return _BN(rmAddress).shl(96).add(internalId);
+}
+
+/**
+ * Create a packed quote message for later signing or hashing.
+ *
+ * Mimics the behaviour of the SignedQuoteRiskModule._newSignedPolicy method.
+ */
+function makeQuoteMessage({ rmAddress, payout, premium, lossProb, expiration, policyData, validUntil }) {
+  return ethers.utils.solidityPack(
+    ["address", "uint256", "uint256", "uint256", "uint40", "bytes32", "uint40"],
+    [rmAddress, payout, premium, lossProb, expiration, policyData, validUntil]
+  );
+}
+
+/**
+ * Create a packed quote message for later signing or hashing.
+ *
+ * Mimics the behaviour of the SignedBucketRiskModule._newSignedPolicy method.
+ */
+function makeBucketQuoteMessage({
+  rmAddress,
+  payout,
+  premium,
+  lossProb,
+  expiration,
+  policyData,
+  bucketId,
+  validUntil,
+}) {
+  return ethers.utils.solidityPack(
+    ["address", "uint256", "uint256", "uint256", "uint40", "bytes32", "uint256", "uint40"],
+    [rmAddress, payout, premium, lossProb, expiration, policyData, bucketId, validUntil]
+  );
+}
+
+/**
+ * Creates and signs a quote message from its policy parameters.
+ *
+ * Mimics the behaviour of policy-quote-api.
+ */
+async function makeSignedQuote(signer, policyParams, makeQuoteMessageFn = makeQuoteMessage) {
+  const quoteMessage = makeQuoteMessageFn(policyParams);
+  return ethers.utils.splitSignature(await signer.signMessage(ethers.utils.arrayify(quoteMessage)));
+}
+
+/**
+ * Build a default policy parameters object.
+ */
+async function defaultPolicyParams(
+  { rmAddress, payout, premium, lossProb, expiration, policyData, validUntil },
+  _A = amountFunction(6)
+) {
+  const now = await helpers.time.latest();
+  return {
+    rmAddress,
+    payout: payout || _A(1000),
+    premium: premium || ethers.constants.MaxUint256,
+    lossProb: lossProb || _W(0.1),
+    expiration: expiration || now + 3600 * 24 * 30,
+    policyData: policyData || ethers.utils.hexlify(ethers.utils.randomBytes(32)),
+    validUntil: validUntil || now + 3600 * 24 * 30,
+  };
+}
+
+module.exports = {
+  _BN,
+  _E,
+  _R,
+  _W,
+  accessControlMessage,
+  amountFunction,
+  defaultPolicyParams,
+  getComponentRole,
+  getDefaultSigner,
+  getRole,
+  getStorageLayout,
+  getTransactionEvent,
+  grantComponentRole,
+  grantRole,
+  makeBucketQuoteMessage,
+  makePolicyId,
+  makeQuoteMessage,
+  makeSignedQuote,
+  RAY,
+  WAD,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ensuro/core",
   "description": "Ensuro - Decentralized insurance protocol",
-  "version": "2.5.0",
+  "version": "v2.6.0-beta1",
   "files": [
     "**/*.sol",
     "/build/contracts/*.json",

package/scripts/storageLayout.js

@@ -1,7 +1,5 @@
 const hre = require("hardhat");
-const { artifacts } = require("hardhat");
-const { findAll } = require("solidity-ast/utils");
-const { getStorageLayout } = require("../test/test-utils");
+const { getStorageLayout } = require("../js/utils");
 
 /**
  * Script to print a contracts storage layout as a table.
@@ -9,11 +7,9 @@ const { getStorageLayout } = require("../test/test-utils");
  * Example usage: node scripts/storageLayout.js EToken
  */
 
-//
-
 async function main(contractSrc, contractName) {
   await hre.run("compile");
-  const layout = await getStorageLayout(contractSrc, contractName);
+  const layout = await getStorageLayout(contractSrc, contractName, hre);
 
   const summary = layout.storage.map((item) => ({
     slot: parseInt(item.slot),
@@ -29,5 +25,6 @@ const [contractSrc, contractName] = [`contracts/${process.argv[2]}.sol`, process
 
 console.log(`Storage layout for ${contractSrc}:${contractName}`);
 main(contractSrc, contractName).then(() => {
+  // eslint-disable-next-line no-process-exit
   process.exit(0);
 });