test: add CoverBroker upgrade + basic functionality (#1373)

Author: MilGard91

package-lock.json

@@ -20,7 +20,7 @@
   },
   "homepage": "https://github.com/NexusMutual/smart-contracts",
   "dependencies": {
-    "@nexusmutual/deployments": "^2.11.1",
+    "@nexusmutual/deployments": "^2.12.0",
     "@nexusmutual/ethers-v5-aws-kms-signer": "^0.0.1",
     "@nomicfoundation/hardhat-network-helpers": "^1.0.12",
     "@openzeppelin/contracts-v4": "npm:@openzeppelin/contracts@^4.7.3",

package.json

@@ -27,7 +27,7 @@ const { parseEther, defaultAbiCoder, toUtf8Bytes, formatEther, parseUnits } = et
 
 const ASSESSMENT_VOTER_COUNT = 3;
 const { USDC_ADDRESS } = Address;
-const { NXM_WHALE_1, NXM_WHALE_2, DAI_NXM_HOLDER, NXMHOLDER, DAI_HOLDER, USDC_HOLDER, HUGH } = UserAddress;
+const { NXM_WHALE_1, NXM_WHALE_2, DAI_NXM_HOLDER, NXMHOLDER, DAI_HOLDER, USDC_HOLDER, NXM_AB_MEMBER } = UserAddress;
 
 let custodyProductId, custodyCoverId;
 let protocolProductId, protocolCoverId;
@@ -59,12 +59,13 @@ const setTime = async timestamp => {
 
 async function castAssessmentVote() {
   // vote
-  for (const abMember of this.abMembers.slice(0, ASSESSMENT_VOTER_COUNT)) {
-    await this.assessment.connect(abMember).castVotes([assessmentId], [true], [''], 0);
-  }
+  await Promise.all(
+    this.abMembers
+      .slice(0, ASSESSMENT_VOTER_COUNT)
+      .map(abMember => this.assessment.connect(abMember).castVotes([assessmentId], [true], [''], 0)),
+  );
 
-  const { poll: pollResult } = await this.assessment.assessments(assessmentId);
-  const poll = pollResult;
+  const { poll } = await this.assessment.assessments(assessmentId);
 
   const payoutCooldown = (await this.assessment.getPayoutCooldown()).toNumber();
 
@@ -92,25 +93,24 @@ describe('basic functionality tests', function () {
   });
 
   it('Impersonate addresses', async function () {
-    await evm.impersonate(NXM_WHALE_1);
-    await evm.impersonate(NXM_WHALE_2);
-    await evm.impersonate(NXMHOLDER);
-    await evm.impersonate(NEW_POOL_MANAGER);
-    await evm.setBalance(NXM_WHALE_1, parseEther('100000'));
-    await evm.setBalance(NXM_WHALE_2, parseEther('100000'));
-    await evm.setBalance(NXMHOLDER, parseEther('100000'));
-    await evm.setBalance(NEW_POOL_MANAGER, parseEther('100000'));
-    await evm.setBalance(DAI_HOLDER, parseEther('100000'));
-    await evm.setBalance(DAI_NXM_HOLDER, parseEther('100000'));
-
-    this.members = [];
-    this.members.push(await getSigner(NXM_WHALE_1));
-    this.members.push(await getSigner(NXM_WHALE_2));
-    this.members.push(await getSigner(NXMHOLDER));
+    await Promise.all([
+      // Impersonate addresses
+      evm.impersonate(NXM_WHALE_1),
+      evm.impersonate(NXM_WHALE_2),
+      evm.impersonate(NXMHOLDER),
+      evm.impersonate(DAI_HOLDER),
+      evm.impersonate(NEW_POOL_MANAGER),
+      // Set balances
+      evm.setBalance(NXM_WHALE_1, parseEther('100000')),
+      evm.setBalance(NXM_WHALE_2, parseEther('100000')),
+      evm.setBalance(NXMHOLDER, parseEther('100000')),
+      evm.setBalance(NEW_POOL_MANAGER, parseEther('100000')),
+      evm.setBalance(DAI_HOLDER, parseEther('100000')),
+      evm.setBalance(DAI_NXM_HOLDER, parseEther('100000')),
+    ]);
 
+    this.members = await Promise.all([NXM_WHALE_1, NXM_WHALE_2, NXMHOLDER].map(address => getSigner(address)));
     this.manager = await getSigner(NEW_POOL_MANAGER);
-
-    await evm.impersonate(DAI_HOLDER);
     this.daiHolder = await getSigner(DAI_HOLDER);
     this.usdcHolder = await getSigner(USDC_HOLDER);
   });
@@ -139,35 +139,41 @@ describe('basic functionality tests', function () {
       return latestAddresses[contractCode];
     }
 
-    for (const contractCode of Object.keys(dependenciesToVerify)) {
-      const dependencies = dependenciesToVerify[contractCode];
+    await Promise.all(
+      Object.keys(dependenciesToVerify).map(async contractCode => {
+        const dependencies = dependenciesToVerify[contractCode];
 
-      const masterAwareV2 = await ethers.getContractAt('IMasterAwareV2', await getLatestAddress(contractCode));
+        const masterAwareV2 = await ethers.getContractAt('IMasterAwareV2', await getLatestAddress(contractCode));
 
-      for (const dependency of dependencies) {
-        const dependencyAddress = await getLatestAddress(dependency);
+        await Promise.all(
+          dependencies.map(async dependency => {
+            const dependencyAddress = await getLatestAddress(dependency);
 
-        const contractId = InternalContractsIDs[dependency];
-        const storedDependencyAddress = await masterAwareV2.internalContracts(contractId);
-        expect(storedDependencyAddress).to.be.equal(
-          dependencyAddress,
-          `Dependency ${dependency} for ${contractCode} is not set correctly ` +
-            `(expected ${dependencyAddress}, got ${storedDependencyAddress})`,
+            const contractId = InternalContractsIDs[dependency];
+            const storedDependencyAddress = await masterAwareV2.internalContracts(contractId);
+            expect(storedDependencyAddress).to.be.equal(
+              dependencyAddress,
+              `Dependency ${dependency} for ${contractCode} is not set correctly ` +
+                `(expected ${dependencyAddress}, got ${storedDependencyAddress})`,
+            );
+          }),
         );
-      }
-    }
+      }),
+    );
   });
 
   it('Stake for assessment', async function () {
     // stake
     const amount = parseEther('200');
-    for (const abMember of this.abMembers.slice(0, ASSESSMENT_VOTER_COUNT)) {
-      const memberAddress = await abMember.getAddress();
-      const { amount: stakeAmountBefore } = await this.assessment.stakeOf(memberAddress);
-      await this.assessment.connect(abMember).stake(amount);
-      const { amount: stakeAmountAfter } = await this.assessment.stakeOf(memberAddress);
-      expect(stakeAmountAfter).to.be.equal(stakeAmountBefore.add(amount));
-    }
+    await Promise.all(
+      this.abMembers.slice(0, ASSESSMENT_VOTER_COUNT).map(async abMember => {
+        const memberAddress = await abMember.getAddress();
+        const { amount: stakeAmountBefore } = await this.assessment.stakeOf(memberAddress);
+        await this.assessment.connect(abMember).stake(amount);
+        const { amount: stakeAmountAfter } = await this.assessment.stakeOf(memberAddress);
+        expect(stakeAmountAfter).to.be.equal(stakeAmountBefore.add(amount));
+      }),
+    );
   });
 
   it('Swap NXM for ETH', async function () {
@@ -584,8 +590,8 @@ describe('basic functionality tests', function () {
   });
 
   it('Buy protocol USDC cover', async function () {
-    await evm.impersonate(HUGH);
-    const coverBuyer = await getSigner(HUGH);
+    await evm.impersonate(NXM_AB_MEMBER);
+    const coverBuyer = await getSigner(NXM_AB_MEMBER);
     const coverBuyerAddress = await coverBuyer.getAddress();
 
     const coverAsset = 6; // USDC
@@ -628,8 +634,8 @@ describe('basic functionality tests', function () {
   });
 
   it('Submit claim for protocol cover in USDC', async function () {
-    await evm.impersonate(HUGH);
-    const coverBuyer = await getSigner(HUGH);
+    await evm.impersonate(NXM_AB_MEMBER);
+    const coverBuyer = await getSigner(NXM_AB_MEMBER);
 
     const claimsCountBefore = await this.individualClaims.getClaimsCount();
     const assessmentCountBefore = await this.assessment.getAssessmentsCount();
@@ -678,10 +684,81 @@ describe('basic functionality tests', function () {
     expect(payoutRedeemed).to.be.equal(true);
   });
 
+  it('buy cover through CoverBroker using ETH', async function () {
+    const coverBuyer = await ethers.Wallet.createRandom().connect(ethers.provider);
+
+    await evm.setBalance(coverBuyer.address, parseEther('1000000'));
+
+    const amount = parseEther('1');
+    const coverCountBefore = await this.cover.getCoverDataCount();
+
+    await this.coverBroker.connect(coverBuyer).buyCover(
+      {
+        coverId: 0,
+        owner: coverBuyer.address,
+        productId: protocolProductId,
+        coverAsset: 0, // ETH
+        amount,
+        period: 3600 * 24 * 30, // 30 days
+        maxPremiumInAsset: parseEther('1').mul(260).div(10000),
+        paymentAsset: 0, // ETH
+        payWithNXM: false,
+        commissionRatio: '500', // 5%,
+        commissionDestination: coverBuyer.address,
+        ipfsData: '',
+      },
+      [{ poolId, coverAmountInAsset: amount }],
+      { value: amount },
+    );
+
+    const coverCountAfter = await this.cover.getCoverDataCount();
+    const coverId = coverCountAfter;
+    const isCoverBuyerOwner = await this.coverNFT.isApprovedOrOwner(coverBuyer.address, coverId);
+
+    expect(isCoverBuyerOwner).to.be.equal(true);
+    expect(coverCountAfter).to.be.equal(coverCountBefore.add(1));
+  });
+
+  it('buy cover through CoverBroker using ERC20 (USDC)', async function () {
+    await evm.impersonate(USDC_HOLDER);
+    await evm.setBalance(USDC_HOLDER, parseEther('1000000'));
+
+    const coverBuyer = await getSigner(USDC_HOLDER);
+    const coverBuyerAddress = await coverBuyer.getAddress();
+
+    const amount = parseUnits('1000', 6);
+    const coverCountBefore = await this.cover.getCoverDataCount();
+
+    await this.usdc.connect(coverBuyer).approve(this.coverBroker.address, MaxUint256);
+    await this.coverBroker.connect(coverBuyer).buyCover(
+      {
+        coverId: 0,
+        owner: coverBuyerAddress,
+        productId: protocolProductId,
+        coverAsset: 6, // USDC
+        amount,
+        period: 3600 * 24 * 30, // 30 days
+        maxPremiumInAsset: amount.mul(260).div(10000),
+        paymentAsset: 6, // USDC
+        payWithNXM: false,
+        commissionRatio: '500', // 5%,
+        commissionDestination: coverBuyerAddress,
+        ipfsData: '',
+      },
+      [{ poolId, coverAmountInAsset: amount }],
+    );
+
+    const coverCountAfter = await this.cover.getCoverDataCount();
+    const coverId = coverCountAfter;
+    const isCoverBuyerOwner = await this.coverNFT.isApprovedOrOwner(coverBuyerAddress, coverId);
+
+    expect(isCoverBuyerOwner).to.be.equal(true);
+    expect(coverCountAfter).to.be.equal(coverCountBefore.add(1));
+  });
+
   it('Edit cover', async function () {
-    // buying cover with USDC
-    await evm.impersonate(HUGH);
-    const coverBuyer = await getSigner(HUGH);
+    await evm.impersonate(NXM_AB_MEMBER);
+    const coverBuyer = await getSigner(NXM_AB_MEMBER);
     const coverBuyerAddress = await coverBuyer.getAddress();
 
     const coverAsset = 6; // USDC