@ensuro/core 2.7.0 → 2.8.0-beta1

package/contracts/mocks/PolicyPoolComponentMock.sol

@@ -20,8 +20,6 @@ contract PolicyPoolComponentMock is IPolicyPoolComponent {
    * @dev See {IERC165-supportsInterface}.
    */
   function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
-    return
-      interfaceId == type(IERC165).interfaceId ||
-      interfaceId == type(IPolicyPoolComponent).interfaceId;
+    return interfaceId == type(IERC165).interfaceId || interfaceId == type(IPolicyPoolComponent).interfaceId;
   }
 }

package/contracts/mocks/PolicyPoolMock.sol

@@ -5,7 +5,6 @@ import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
 import {IRiskModule} from "../interfaces/IRiskModule.sol";
 import {IEToken} from "../interfaces/IEToken.sol";
 import {IAccessManager} from "../interfaces/IAccessManager.sol";
-import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {Policy} from "../Policy.sol";
 import {ForwardProxy} from "./ForwardProxy.sol";
@@ -13,8 +12,7 @@ import {ForwardProxy} from "./ForwardProxy.sol";
 contract PolicyPoolMock is IPolicyPool {
   using Policy for Policy.PolicyData;
 
-  uint256 public constant MAX_INT =
-    0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
+  uint256 public constant MAX_INT = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
 
   IERC20Metadata internal _currency;
   IAccessManager internal _access;
@@ -44,8 +42,8 @@ contract PolicyPoolMock is IPolicyPool {
 
   function newPolicy(
     Policy.PolicyData memory policy,
-    address, /* caller */
-    address, /* policyHolder */
+    address /* caller */,
+    address /* policyHolder */,
     uint96 internalId
   ) external override returns (uint256) {
     policy.id = (uint256(uint160(address(policy.riskModule))) << 96) + internalId;
@@ -57,10 +55,7 @@ contract PolicyPoolMock is IPolicyPool {
   function _resolvePolicy(Policy.PolicyData memory policy, uint256 payout) internal {
     require(policy.id != 0, "Policy not found");
     require(policy.hash() == policyHashes[policy.id], "Hash doesn't match");
-    require(
-      msg.sender == address(policy.riskModule),
-      "Only riskModule is authorized to resolve the policy"
-    );
+    require(msg.sender == address(policy.riskModule), "Only riskModule is authorized to resolve the policy");
     delete policies[policy.id];
     delete policyHashes[policy.id];
     emit PolicyResolved(IRiskModule(msg.sender), policy.id, payout);
@@ -74,10 +69,7 @@ contract PolicyPoolMock is IPolicyPool {
     _resolvePolicy(policy, 0);
   }
 
-  function resolvePolicyFullPayout(Policy.PolicyData calldata policy, bool customerWon)
-    external
-    override
-  {
+  function resolvePolicyFullPayout(Policy.PolicyData calldata policy, bool customerWon) external override {
     return _resolvePolicy(policy, customerWon ? policy.payout : 0);
   }
 
@@ -108,14 +100,7 @@ contract PolicyPoolMock is IPolicyPool {
     uint256 lossProb,
     uint40 expiration
   ) external {
-    Policy.PolicyData memory policy = Policy.initialize(
-      riskModule,
-      rmParams,
-      premium,
-      payout,
-      lossProb,
-      expiration
-    );
+    Policy.PolicyData memory policy = Policy.initialize(riskModule, rmParams, premium, payout, lossProb, expiration);
 
     emit NewPolicy(riskModule, policy);
   }
@@ -127,17 +112,12 @@ contract PolicyPoolMock is IPolicyPool {
  *      and other contracts that have functions that can be called only from PolicyPool
  */
 contract PolicyPoolMockForward is ForwardProxy {
-  uint256 public constant MAX_INT =
-    0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
+  uint256 public constant MAX_INT = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
 
   IERC20Metadata internal _currency;
   IAccessManager internal _access;
 
-  constructor(
-    address forwardTo,
-    IERC20Metadata currency_,
-    IAccessManager access_
-  ) ForwardProxy(forwardTo) {
+  constructor(address forwardTo, IERC20Metadata currency_, IAccessManager access_) ForwardProxy(forwardTo) {
     _currency = currency_;
     _access = access_;
   }

package/contracts/mocks/RiskModuleMock.sol

@@ -20,9 +20,7 @@ contract RiskModuleMock is RiskModule {
 
   /// @custom:oz-upgrades-unsafe-allow constructor
   // solhint-disable-next-line no-empty-blocks
-  constructor(IPolicyPool policyPool_, IPremiumsAccount premiumsAccount_)
-    RiskModule(policyPool_, premiumsAccount_)
-  {} // solhint-disable-line no-empty-blocks
+  constructor(IPolicyPool policyPool_, IPremiumsAccount premiumsAccount_) RiskModule(policyPool_, premiumsAccount_) {}
 
   /**
    * @dev Initializes the RiskModule
@@ -43,15 +41,7 @@ contract RiskModuleMock is RiskModule {
     uint256 exposureLimit_,
     address wallet_
   ) public initializer {
-    __RiskModule_init(
-      name_,
-      collRatio_,
-      ensuroPpFee_,
-      srRoc_,
-      maxPayoutPerPolicy_,
-      exposureLimit_,
-      wallet_
-    );
+    __RiskModule_init(name_, collRatio_, ensuroPpFee_, srRoc_, maxPayoutPerPolicy_, exposureLimit_, wallet_);
   }
 
   function newPolicy(
@@ -66,10 +56,7 @@ contract RiskModuleMock is RiskModule {
     return _newPolicy(payout, premium, lossProb, expiration, payer, onBehalfOf, internalId).id;
   }
 
-  function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout)
-    external
-    onlyComponentRole(RESOLVER_ROLE)
-  {
+  function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout) external onlyComponentRole(RESOLVER_ROLE) {
     _policyPool.resolvePolicy(policy, payout);
   }
 }

package/contracts/mocks/TestNFT.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.0;
 pragma experimental ABIEncoderV2;
 
-import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 
 contract TestNFT is ERC721 {
   address private _owner;

package/js/deploy.js

@@ -77,9 +77,10 @@ async function logContractCreated(hre, contractName, address) {
 async function verifyContract(hre, contract, isProxy, constructorArguments) {
   if (isProxy === undefined) isProxy = false;
   if (constructorArguments === undefined) constructorArguments = [];
+  const contractAddr = await ethers.resolveAddress(contract);
   const address = isProxy
-    ? await upgrades_core.getImplementationAddress(hre.network.provider, contract.address)
-    : contract.address;
+    ? await upgrades_core.getImplementationAddress(hre.network.provider, contractAddr)
+    : contractAddr;
   try {
     await hre.run("verify:verify", {
       address: address,
@@ -97,27 +98,29 @@ async function verifyContract(hre, contract, isProxy, constructorArguments) {
   try {
     if (isProxy) {
       await hre.run("verify:verify", {
-        address: contract.address,
+        address: contractAddr,
+        constructorArguments: constructorArguments,
       });
     }
   } catch (error) {
     console.log("Error verifying contract proxy: ", error);
     const endpoints = await hre.run("verify:get-etherscan-endpoint");
-    console.log(`You should do it manually at ${endpoints.urls.browserURL}/proxyContractChecker?a=${contract.address}`);
+    console.log(`You should do it manually at ${endpoints.urls.browserURL}/proxyContractChecker?a=${contractAddr}`);
   }
 }
 
 async function deployContract({ saveAddr, verify, contractClass, constructorArgs }, hre) {
   const ContractFactory = await hre.ethers.getContractFactory(contractClass);
   const contract = await ContractFactory.deploy(...constructorArgs, txOverrides());
+  const contractAddr = await ethers.resolveAddress(contract);
   if (verify) {
     // From https://ethereum.stackexchange.com/a/119622/79726
     await contract.deployTransaction.wait(6);
   } else {
-    await contract.deployed();
+    await contract.waitForDeployment();
   }
-  await logContractCreated(hre, contractClass, contract.address);
-  saveAddress(saveAddr, contract.address);
+  await logContractCreated(hre, contractClass, contractAddr);
+  saveAddress(saveAddr, contractAddr);
   if (verify) await verifyContract(hre, contract, false, constructorArgs);
   return { ContractFactory, contract };
 }
@@ -133,14 +136,15 @@ async function deployProxyContract(
     initializer: initializer,
     ...deployProxyArgs,
   });
+  const contractAddr = await ethers.resolveAddress(contract);
   if (verify) {
     // From https://ethereum.stackexchange.com/a/119622/79726
     await contract.deployTransaction.wait(6);
   } else {
-    await contract.deployed();
+    await contract.waitForDeployment();
   }
-  await logContractCreated(hre, contractClass, contract.address);
-  saveAddress(saveAddr, contract.address);
+  await logContractCreated(hre, contractClass, contractAddr);
+  saveAddress(saveAddr, contractAddr);
   if (verify) await verifyContract(hre, contract, true, constructorArgs);
   return { ContractFactory, contract };
 }
@@ -154,7 +158,7 @@ async function grantRoleTask({ contractAddress, role, account, component, impers
     }
     contract = contract.connect(signer);
   }
-  if (component === ethers.constants.AddressZero) {
+  if (component === ethers.ZeroAddress) {
     await grantRole(hre, contract, role, account, txOverrides(), console.log);
   } else {
     await grantComponentRole(hre, contract, component, role, account, txOverrides(), console.log);
@@ -171,11 +175,11 @@ async function deployTestCurrency({ currName, currSymbol, initialSupply, ...opts
       },
       hre
     )
-  ).contract.address;
+  ).contract;
 }
 
 async function deployAccessManager(opts, hre) {
-  return (await deployProxyContract({ contractClass: "AccessManager", ...opts }, hre)).contract.address;
+  return (await deployProxyContract({ contractClass: "AccessManager", ...opts }, hre)).contract;
 }
 
 async function deployPolicyPool({ accessAddress, currencyAddress, nftName, nftSymbol, treasuryAddress, ...opts }, hre) {
@@ -189,7 +193,7 @@ async function deployPolicyPool({ accessAddress, currencyAddress, nftName, nftSy
       },
       hre
     )
-  ).contract.address;
+  ).contract;
 }
 
 async function deployEToken(
@@ -209,9 +213,9 @@ async function deployEToken(
   if (opts.addComponent) {
     let policyPool = await hre.ethers.getContractAt("PolicyPool", poolAddress);
     if (runAs) policyPool = policyPool.connect(runAs);
-    await policyPool.addComponent(contract.address, 1);
+    await policyPool.addComponent(contract, 1);
   }
-  return contract.address;
+  return contract;
 }
 
 async function deployPremiumsAccount({ poolAddress, juniorEtk, seniorEtk, runAs, ...opts }, hre) {
@@ -228,9 +232,9 @@ async function deployPremiumsAccount({ poolAddress, juniorEtk, seniorEtk, runAs,
   if (opts.addComponent) {
     let policyPool = await hre.ethers.getContractAt("PolicyPool", poolAddress);
     if (runAs) policyPool = policyPool.connect(runAs);
-    await policyPool.addComponent(contract.address, 3);
+    await policyPool.addComponent(contract, 3);
   }
-  return contract.address;
+  return contract;
 }
 
 async function deployRiskModule(
@@ -281,7 +285,6 @@ async function deployRiskModule(
     hre
   );
   const rm = runAs === undefined ? contract : contract.connect(runAs);
-
   if (opts.addComponent) {
     if (moc != 1.0) {
       moc = _W(moc);
@@ -304,9 +307,9 @@ async function deployRiskModule(
     }
     let policyPool = await hre.ethers.getContractAt("PolicyPool", poolAddress);
     if (runAs) policyPool = policyPool.connect(runAs);
-    await policyPool.addComponent(contract.address, 2);
+    await policyPool.addComponent(contract, 2);
   }
-  return contract.address;
+  return contract;
 }
 
 async function deploySignedQuoteRM(opts, hre) {
@@ -319,9 +322,9 @@ async function setAssetManager({ reserve, amAddress, liquidityMin, liquidityMidd
   const tx = await reserveContract.setAssetManager(amAddress, false);
   console.log(`Asset Manager ${amAddress} set to reserve ${reserve}`);
   if (liquidityMin !== undefined || liquidityMiddle !== undefined || liquidityMax !== undefined) {
-    liquidityMin = liquidityMin === undefined ? ethers.constants.MaxUint256 : _A(liquidityMin);
-    liquidityMiddle = liquidityMiddle === undefined ? ethers.constants.MaxUint256 : _A(liquidityMiddle);
-    liquidityMax = liquidityMax === undefined ? ethers.constants.MaxUint256 : _A(liquidityMax);
+    liquidityMin = liquidityMin === undefined ? ethers.MaxUint256 : _A(liquidityMin);
+    liquidityMiddle = liquidityMiddle === undefined ? ethers.MaxUint256 : _A(liquidityMiddle);
+    liquidityMax = liquidityMax === undefined ? ethers.MaxUint256 : _A(liquidityMax);
     const amContract = await hre.ethers.getContractAt(
       "ERC4626AssetManager", // Not relevant if it's ERC4626AssetManager, only need setLiquidityThresholds
       amAddress
@@ -346,7 +349,7 @@ async function deployERC4626AssetManager({ asset, vault, amClass, ...opts }, hre
       },
       hre
     )
-  ).contract.address;
+  ).contract;
 }
 
 async function deployAaveAssetManager({ asset, aave, amClass, ...opts }, hre) {
@@ -359,7 +362,7 @@ async function deployAaveAssetManager({ asset, aave, amClass, ...opts }, hre) {
       },
       hre
     )
-  ).contract.address;
+  ).contract;
 }
 
 async function deployWhitelist(
@@ -386,17 +389,17 @@ async function deployWhitelist(
   );
   if (eToken !== undefined) {
     const etk = await hre.ethers.getContractAt("EToken", eToken);
-    await etk.setWhitelist(contract.address);
+    await etk.setWhitelist(contract);
   }
   if (eToken2 !== undefined) {
     const etk = await hre.ethers.getContractAt("EToken", eToken2);
-    await etk.setWhitelist(contract.address);
+    await etk.setWhitelist(contract);
   }
   if (eToken3 !== undefined) {
     const etk = await hre.ethers.getContractAt("EToken", eToken3);
-    await etk.setWhitelist(contract.address);
+    await etk.setWhitelist(contract);
   }
-  return contract.address;
+  return contract;
 }
 
 async function trustfullPolicy({ rmAddress, payout, premium, lossProb, expiration, customer }, hre) {
@@ -409,7 +412,7 @@ async function trustfullPolicy({ rmAddress, payout, premium, lossProb, expiratio
   customer = customer || (await getDefaultSigner(hre));
   premium = _A(premium);
 
-  await currency.approve(policyPool.address, premium);
+  await currency.approve(policyPool, premium);
   lossProb = _W(lossProb);
   if (expiration === undefined) {
     expiration = 3600;
@@ -453,7 +456,7 @@ async function flightDelayPolicy(
   customer = customer || (await getDefaultSigner(hre));
   premium = _A(premium);
 
-  await currency.approve(policyPool.address, premium);
+  await currency.approve(policyPool, premium);
   lossProb = _W(lossProb);
   payout = _A(payout);
 
@@ -480,7 +483,7 @@ async function listETokens({ poolAddress }, hre) {
   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}`);
+    console.log(`eToken at ${etk.target}: ${etkName}`);
   }
 }
 
@@ -489,8 +492,8 @@ async function deposit({ etkAddress, amount }, hre) {
   const policyPool = await hre.ethers.getContractAt("PolicyPool", await etk.policyPool());
   const currency = await hre.ethers.getContractAt("IERC20Metadata", await policyPool.currency());
   amount = _A(amount);
-  await currency.approve(policyPool.address, amount);
-  const tx = await policyPool.deposit(etk.address, amount, { gasLimit: 999999 });
+  await currency.approve(policyPool, amount);
+  const tx = await policyPool.deposit(etk, amount, { gasLimit: 999999 });
   console.log(tx);
 }
 
@@ -508,11 +511,13 @@ function add_task() {
     .setAction(async function (taskArgs, hre) {
       if (taskArgs.currencyAddress === undefined) {
         taskArgs.saveAddr = "CURRENCY";
-        taskArgs.currencyAddress = await deployTestCurrency(taskArgs, hre);
+        const currency = await deployTestCurrency(taskArgs, hre);
+        taskArgs.currencyAddress = await ethers.resolveAddress(currency);
       }
       if (taskArgs.accessAddress === undefined) {
         taskArgs.saveAddr = "ACCESSMANAGER";
-        taskArgs.accessAddress = await deployAccessManager(taskArgs, hre);
+        const access = await deployAccessManager(taskArgs, hre);
+        taskArgs.accessAddress = await ethers.resolveAddress(access);
       }
       taskArgs.saveAddr = "POOL";
       await deployPolicyPool(taskArgs, hre);
@@ -536,7 +541,7 @@ function add_task() {
     .addOptionalParam("saveAddr", "Save created contract address", "POOL", types.str)
     .addOptionalParam("nftName", "Name of Policies NFT Token", "Ensuro Policies NFT", types.str)
     .addOptionalParam("nftSymbol", "Symbol of Policies NFT Token", "EPOL", types.str)
-    .addOptionalParam("treasuryAddress", "Treasury Address", ethers.constants.AddressZero, types.address)
+    .addOptionalParam("treasuryAddress", "Treasury Address", ethers.ZeroAddress, types.address)
     .addParam("currencyAddress", "Currency Address", types.address)
     .addParam("accessAddress", "AccessManager Address", types.address)
     .setAction(deployPolicyPool);
@@ -692,7 +697,7 @@ function add_task() {
     .addOptionalParam(
       "component",
       "Address of the component if it's a component role",
-      ethers.constants.AddressZero,
+      ethers.ZeroAddress,
       types.address
     )
     .setAction(grantRoleTask);

package/js/test-utils.js

@@ -4,7 +4,7 @@ const { RiskModuleParameter } = require("../js/enums");
 const helpers = require("@nomicfoundation/hardhat-network-helpers");
 
 const { ethers } = hre;
-const { AddressZero } = ethers.constants;
+const { ZeroAddress } = ethers;
 
 async function initCurrency(options, initial_targets, initial_balances) {
   const Currency = await ethers.getContractFactory(options.contractClass || "TestCurrency");
@@ -17,7 +17,7 @@ async function initCurrency(options, initial_targets, initial_balances) {
   initial_targets = initial_targets || [];
   await Promise.all(
     initial_targets.map(async function (user, index) {
-      await currency.transfer(user.address, initial_balances[index]);
+      await currency.transfer(user, initial_balances[index]);
     })
   );
   return currency;
@@ -33,11 +33,11 @@ async function initCurrency(options, initial_targets, initial_balances) {
 async function initForkCurrency(currencyAddress, currencyOrigin, initialTargets, initialBalances) {
   const currency = await ethers.getContractAt("IERC20", currencyAddress);
   await helpers.impersonateAccount(currencyOrigin);
-  await helpers.setBalance(currencyOrigin, ethers.utils.parseEther("100"));
+  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.address, initialBalances[index]);
+      await currency.connect(whale).transfer(user, initialBalances[index]);
     })
   );
   return currency;
@@ -63,6 +63,11 @@ async function createRiskModule(
   extraArgs = extraArgs || [];
   extraConstructorArgs = extraConstructorArgs || [];
   const _A = pool._A || _W;
+  maxPayoutPerPolicy = maxPayoutPerPolicy !== undefined ? _A(maxPayoutPerPolicy) : _A(1000);
+  exposureLimit = exposureLimit !== undefined ? _A(exposureLimit) : _A(1000000);
+
+  const poolAddr = await ethers.resolveAddress(pool);
+  const paAddr = await ethers.resolveAddress(premiumsAccount);
   const rm = await hre.upgrades.deployProxy(
     contractFactory,
     [
@@ -70,18 +75,18 @@ async function createRiskModule(
       _W(collRatio) || _W(1),
       _W(ensuroPPFee) || _W(0),
       _W(srRoc) || _W("0.1"),
-      _A(maxPayoutPerPolicy) || _A(1000),
-      _A(exposureLimit) || _A(1000000),
+      maxPayoutPerPolicy,
+      exposureLimit,
       wallet || "0xdD2FD4581271e230360230F9337D5c0430Bf44C0", // Random address
       ...extraArgs,
     ],
     {
       kind: "uups",
-      constructorArgs: [pool.address, premiumsAccount.address, ...extraConstructorArgs],
+      constructorArgs: [poolAddr, paAddr, ...extraConstructorArgs],
     }
   );
 
-  await rm.deployed();
+  await rm.waitForDeployment();
 
   if (moc !== undefined && moc != 1.0) {
     moc = _W(moc);
@@ -120,7 +125,7 @@ async function addRiskModule(
     extraConstructorArgs,
   });
 
-  await pool.addComponent(rm.address, 2);
+  await pool.addComponent(rm, 2);
   return rm;
 }
 
@@ -131,6 +136,7 @@ async function createEToken(
   const EToken = await ethers.getContractFactory("EToken");
   extraArgs = extraArgs || [];
   extraConstructorArgs = extraConstructorArgs || [];
+  const poolAddr = await ethers.resolveAddress(pool);
   const etk = await hre.upgrades.deployProxy(
     EToken,
     [
@@ -143,11 +149,11 @@ async function createEToken(
     {
       kind: "uups",
       unsafeAllow: ["delegatecall"], // This holds, because EToken is a reserve and uses delegatecall
-      constructorArgs: [pool.address, ...extraConstructorArgs],
+      constructorArgs: [poolAddr, ...extraConstructorArgs],
     }
   );
 
-  await etk.deployed();
+  await etk.waitForDeployment();
   return etk;
 }
 
@@ -163,7 +169,7 @@ async function addEToken(
     extraArgs,
     extraConstructorArgs,
   });
-  await pool.addComponent(etk.address, 1);
+  await pool.addComponent(etk, 1);
   return etk;
 }
 
@@ -192,11 +198,13 @@ async function deployPool(options) {
   if (options.access === undefined) {
     // Deploy AccessManager
     accessManager = await hre.upgrades.deployProxy(AccessManager, [], { kind: "uups" });
-    await accessManager.deployed();
+    await accessManager.waitForDeployment();
   } else {
     accessManager = await ethers.getContractAt("AccessManager", options.access);
   }
 
+  const currencyAddr = await ethers.resolveAddress(options.currency);
+  const amAddr = await ethers.resolveAddress(accessManager);
   const policyPool = await hre.upgrades.deployProxy(
     PolicyPool,
     [
@@ -205,12 +213,12 @@ async function deployPool(options) {
       options.treasuryAddress || randomAddress,
     ],
     {
-      constructorArgs: [accessManager.address, options.currency],
+      constructorArgs: [amAddr, currencyAddr],
       kind: "uups",
     }
   );
 
-  await policyPool.deployed();
+  await policyPool.waitForDeployment();
 
   for (const role of options.grantRoles || []) {
     await grantRole(hre, accessManager, role);
@@ -227,21 +235,24 @@ async function deployPool(options) {
 
 async function deployPremiumsAccount(pool, options, addToPool = true) {
   const PremiumsAccount = await ethers.getContractFactory("PremiumsAccount");
+  const poolAddr = await ethers.resolveAddress(pool);
+  const jrEtkAddr = options.jrEtk ? await ethers.resolveAddress(options.jrEtk) : ZeroAddress;
+  const srEtkAddr = options.srEtk ? await ethers.resolveAddress(options.srEtk) : ZeroAddress;
   const premiumsAccount = await hre.upgrades.deployProxy(PremiumsAccount, [], {
-    constructorArgs: [pool.address, options.jrEtkAddr || AddressZero, options.srEtkAddr || AddressZero],
+    constructorArgs: [poolAddr, jrEtkAddr, srEtkAddr],
     kind: "uups",
     unsafeAllow: ["delegatecall"], // This holds, because EToken is a reserve and uses delegatecall
   });
 
-  await premiumsAccount.deployed();
+  await premiumsAccount.waitForDeployment();
 
-  if (addToPool) await pool.addComponent(premiumsAccount.address, 3);
+  if (addToPool) await pool.addComponent(premiumsAccount, 3);
 
   return premiumsAccount;
 }
 
 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 tx = await rm.connect(cust)[method](payout, premium, lossProb, expiration, cust, internalId);
   let receipt = await tx.wait();
   const newPolicyEvt = getTransactionEvent(pool.interface, receipt, "NewPolicy");