chore: proxy and integration test update

Author: Anmol-Dhiman

contracts/test/integration/index.ts

@@ -1,7 +1,7 @@
 import { anyValue } from "@nomicfoundation/hardhat-chai-matchers/withArgs";
 import { expect } from "chai";
 import { deployments, ethers, getNamedAccounts, network } from "hardhat";
-import { BigNumber } from "ethers";
+import { toBigInt, BytesLike } from "ethers";
 import {
   PNK,
   KlerosCore,
@@ -19,10 +19,11 @@ import {
 /* eslint-disable no-unused-expressions */ // https://github.com/standard/standard/issues/690#issuecomment-278533482
 
 describe("Integration tests", async () => {
-  const ONE_TENTH_ETH = BigNumber.from(10).pow(17);
-  const ONE_ETH = BigNumber.from(10).pow(18);
-  const ONE_HUNDRED_PNK = BigNumber.from(10).pow(20);
-  const ONE_THOUSAND_PNK = BigNumber.from(10).pow(21);
+  const ONE_TENTH_ETH = toBigInt(10) ** toBigInt(17);
+  const ONE_ETH = toBigInt(10) ** toBigInt(18);
+  const ONE_HUNDRED_PNK = toBigInt(10) ** toBigInt(20);
+  const ONE_THOUSAND_PNK = toBigInt(10) ** toBigInt(21);
+  const abiCoder = ethers.AbiCoder.defaultAbiCoder();
 
   const enum Period {
     evidence, // Evidence can be submitted. This is also when drawing has to take place.
@@ -39,7 +40,16 @@ describe("Integration tests", async () => {
   }
 
   let deployer;
-  let rng, randomizer, disputeKit, pnk, core, vea, foreignGateway, arbitrable, homeGateway, sortitionModule;
+  let rng: RandomizerRNG,
+    randomizer: RandomizerMock,
+    disputeKit: DisputeKitClassic,
+    pnk: PNK,
+    core: KlerosCore,
+    vea: VeaMock,
+    foreignGateway: ForeignGateway,
+    arbitrable: ArbitrableExample,
+    homeGateway: HomeGateway,
+    sortitionModule: SortitionModule;
 
   beforeEach("Setup", async () => {
     ({ deployer } = await getNamedAccounts());
@@ -60,10 +70,10 @@ describe("Integration tests", async () => {
   });
 
   it("Resolves a dispute on the home chain with no appeal", async () => {
-    const arbitrationCost = ONE_TENTH_ETH.mul(3);
+    const arbitrationCost = ONE_TENTH_ETH * toBigInt(3);
     const [, , relayer] = await ethers.getSigners();
 
-    await pnk.approve(core.address, ONE_THOUSAND_PNK.mul(100));
+    await pnk.approve(core.target, ONE_THOUSAND_PNK * toBigInt(100));
 
     await core.setStake(1, ONE_THOUSAND_PNK);
     await sortitionModule.getJurorBalance(deployer, 1).then((result) => {
@@ -72,9 +82,9 @@ describe("Integration tests", async () => {
       logJurorBalance(result);
     });
 
-    await core.setStake(1, ONE_HUNDRED_PNK.mul(5));
+    await core.setStake(1, ONE_HUNDRED_PNK * toBigInt(5));
     await sortitionModule.getJurorBalance(deployer, 1).then((result) => {
-      expect(result.totalStaked).to.equal(ONE_HUNDRED_PNK.mul(5));
+      expect(result.totalStaked).to.equal(ONE_HUNDRED_PNK * toBigInt(5));
       expect(result.totalLocked).to.equal(0);
       logJurorBalance(result);
     });
@@ -86,48 +96,48 @@ describe("Integration tests", async () => {
       logJurorBalance(result);
     });
 
-    await core.setStake(1, ONE_THOUSAND_PNK.mul(4));
+    await core.setStake(1, ONE_THOUSAND_PNK * toBigInt(4));
     await sortitionModule.getJurorBalance(deployer, 1).then((result) => {
-      expect(result.totalStaked).to.equal(ONE_THOUSAND_PNK.mul(4));
+      expect(result.totalStaked).to.equal(ONE_THOUSAND_PNK * toBigInt(4));
       expect(result.totalLocked).to.equal(0);
       logJurorBalance(result);
     });
-    const tx = await arbitrable.functions["createDispute(string)"]("future of france", {
+    const tx = await arbitrable["createDispute(string)"]("future of france", {
       value: arbitrationCost,
     });
     const trace = await network.provider.send("debug_traceTransaction", [tx.hash]);
-    const [disputeId] = ethers.utils.defaultAbiCoder.decode(["uint"], `0x${trace.returnValue}`); // get returned value from createDispute()
+    const [disputeId] = abiCoder.decode(["uint"], `0x${trace.returnValue}`); // get returned value from createDispute()
     console.log("Dispute Created with disputeId: %d", disputeId);
     await expect(tx)
       .to.emit(foreignGateway, "CrossChainDisputeOutgoing")
-      .withArgs(anyValue, arbitrable.address, 1, 2, "0x00");
+      .withArgs(anyValue, arbitrable.target, 1, 2, "0x00");
     await expect(tx)
       .to.emit(arbitrable, "DisputeRequest")
       .withArgs(
-        foreignGateway.address,
+        foreignGateway.target,
         1,
-        BigNumber.from("46619385602526556702049273755915206310773794210139929511467397410441395547901"),
+        toBigInt("46619385602526556702049273755915206310773794210139929511467397410441395547901"),
         0,
         ""
       );
 
-    const lastBlock = await ethers.provider.getBlock(tx.blockNumber - 1);
-    const disputeHash = ethers.utils.solidityKeccak256(
+    const lastBlock = await ethers.provider.getBlock(tx.blockNumber ?? 0 - 1);
+    const disputeHash = ethers.solidityPackedKeccak256(
       ["bytes", "bytes32", "uint256", "address", "uint256", "uint256", "bytes"],
-      [ethers.utils.toUtf8Bytes("createDispute"), lastBlock.hash, 31337, arbitrable.address, disputeId, 2, "0x00"]
+      [ethers.toUtf8Bytes("createDispute"), lastBlock?.hash, 31337, arbitrable.target, disputeId, 2, "0x00"]
     );
     console.log("dispute hash: ", disputeHash);
 
     // Relayer tx
     const tx2 = await homeGateway
       .connect(relayer)
-      .functions["relayCreateDispute((bytes32,uint256,address,uint256,uint256,uint256,string,uint256,bytes))"](
+      ["relayCreateDispute((bytes32,uint256,address,uint256,uint256,uint256,string,uint256,bytes))"](
         {
-          foreignBlockHash: lastBlock.hash,
+          foreignBlockHash: lastBlock?.hash as BytesLike,
           foreignChainID: 31337,
-          foreignArbitrable: arbitrable.address,
+          foreignArbitrable: arbitrable.target,
           foreignDisputeID: disputeId,
-          externalDisputeID: ethers.utils.keccak256(ethers.utils.toUtf8Bytes("future of france")),
+          externalDisputeID: ethers.keccak256(ethers.toUtf8Bytes("future of france")),
           templateId: 0,
           templateUri: "",
           choices: 2,
@@ -136,7 +146,7 @@ describe("Integration tests", async () => {
         { value: arbitrationCost }
       );
     expect(tx2).to.emit(homeGateway, "Dispute");
-    const events2 = (await tx2.wait()).events;
+    await tx2.wait();
 
     await network.provider.send("evm_increaseTime", [2000]); // Wait for minStakingTime
     await network.provider.send("evm_mine");
@@ -146,23 +156,23 @@ describe("Integration tests", async () => {
     console.log("KC phase: %d", await sortitionModule.phase());
 
     await sortitionModule.passPhase(); // Staking -> Generating
-    await mineBlocks(await sortitionModule.rngLookahead()); // Wait for finality
+    await mineBlocks(ethers.getNumber(await sortitionModule.rngLookahead())); // Wait for finality
     expect(await sortitionModule.phase()).to.equal(Phase.generating);
     console.log("KC phase: %d", await sortitionModule.phase());
-    await randomizer.relay(rng.address, 0, ethers.utils.randomBytes(32));
+    await randomizer.relay(rng.target, 0, ethers.randomBytes(32));
     await sortitionModule.passPhase(); // Generating -> Drawing
     expect(await sortitionModule.phase()).to.equal(Phase.drawing);
     console.log("KC phase: %d", await sortitionModule.phase());
 
     const tx3 = await core.draw(0, 1000);
     console.log("draw successful");
-    const events3 = (await tx3.wait()).events;
+    await tx3.wait();
 
     const roundInfo = await core.getRoundInfo(0, 0);
     expect(roundInfo.drawnJurors).deep.equal([deployer, deployer, deployer]);
-    expect(roundInfo.pnkAtStakePerJuror).to.equal(ONE_HUNDRED_PNK.mul(2));
+    expect(roundInfo.pnkAtStakePerJuror).to.equal(ONE_HUNDRED_PNK * toBigInt(2));
     expect(roundInfo.totalFeesForJurors).to.equal(arbitrationCost);
-    expect(roundInfo.feeToken).to.equal(ethers.constants.AddressZero);
+    expect(roundInfo.feeToken).to.equal(ethers.ZeroAddress);
 
     expect((await core.disputes(0)).period).to.equal(Period.evidence);
 
@@ -180,8 +190,8 @@ describe("Integration tests", async () => {
 
     const tx4 = await core.executeRuling(0, { gasLimit: 10000000, gasPrice: 5000000000 });
     console.log("Ruling executed on KlerosCore");
-    expect(tx4).to.emit(core, "Ruling").withArgs(homeGateway.address, 0, 0);
-    expect(tx4).to.emit(arbitrable, "Ruling").withArgs(foreignGateway.address, 1, 0); // The ForeignGateway starts counting disputeID from 1.
+    expect(tx4).to.emit(core, "Ruling").withArgs(homeGateway.target, 0, 0);
+    expect(tx4).to.emit(arbitrable, "Ruling").withArgs(foreignGateway.target, 1, 0); // The ForeignGateway starts counting disputeID from 1.
   });
 
   const mineBlocks = async (n: number) => {
@@ -192,9 +202,5 @@ describe("Integration tests", async () => {
 });
 
 const logJurorBalance = async (result) => {
-  console.log(
-    "staked=%s, locked=%s",
-    ethers.utils.formatUnits(result.totalStaked),
-    ethers.utils.formatUnits(result.totalLocked)
-  );
+  console.log("staked=%s, locked=%s", ethers.formatUnits(result.totalLocked), ethers.formatUnits(result.totalStaked));
 };

contracts/test/proxy/index.ts

@@ -68,22 +68,22 @@ describe("Upgradability", async () => {
           const UUPSUnsupportedProxiableUUIDFactory = await ethers.getContractFactory("UUPSUnsupportedProxiableUUID");
           const uupsUnsupportedUUID = await UUPSUnsupportedProxiableUUIDFactory.deploy();
           await expect(
-            proxy.connect(deployer).upgradeToAndCall(uupsUnsupportedUUID.address, "0x")
+            proxy.connect(deployer).upgradeToAndCall(uupsUnsupportedUUID.target, "0x")
           ).to.be.revertedWithCustomError(proxy, "UUPSUnsupportedProxiableUUID");
         });
         it("Should revert on upgrades to non UUPS-compliant implementation", async () => {
           const NonUpgradeableMockFactory = await ethers.getContractFactory("NonUpgradeableMock");
           const nonUpgradeableMock = await NonUpgradeableMockFactory.deploy();
-          await expect(proxy.upgradeToAndCall(nonUpgradeableMock.address, "0x"))
+          await expect(proxy.upgradeToAndCall(nonUpgradeableMock.target, "0x"))
             .to.be.revertedWithCustomError(proxy, "InvalidImplementation")
-            .withArgs(nonUpgradeableMock.address);
+            .withArgs(nonUpgradeableMock.target);
         });
         it("Should revert if upgrade is performed directly through the implementation", async () => {
           // In the implementation, the `governor` storage slot is not initialized so `governor === address(0)`, which fails _authorizeUpgrade()
           const UUPSUpgradeableMockV2Factory = await ethers.getContractFactory("UUPSUpgradeableMockV2");
           const newImplementation = await UUPSUpgradeableMockV2Factory.connect(deployer).deploy();
           await expect(
-            implementation.connect(deployer).upgradeToAndCall(newImplementation.address, "0x")
+            implementation.connect(deployer).upgradeToAndCall(newImplementation.target, "0x")
           ).to.be.revertedWith("No privilege to upgrade");
         });
       });
@@ -93,15 +93,15 @@ describe("Upgradability", async () => {
           // Unauthorized user try to upgrade the implementation
           const UUPSUpgradeableMockV2Factory = await ethers.getContractFactory("UUPSUpgradeableMockV2");
           let upgradable = await UUPSUpgradeableMockV2Factory.connect(user1).deploy();
-          await expect(proxy.connect(user1).upgradeToAndCall(upgradable.address, "0x")).to.be.revertedWith(
+          await expect(proxy.connect(user1).upgradeToAndCall(upgradable.target, "0x")).to.be.revertedWith(
             "No privilege to upgrade"
           );
 
           // Governor updates the implementation
           upgradable = await UUPSUpgradeableMockV2Factory.connect(deployer).deploy();
-          await expect(proxy.connect(deployer).upgradeToAndCall(upgradable.address, "0x"))
+          await expect(proxy.connect(deployer).upgradeToAndCall(upgradable.target, "0x"))
             .to.emit(proxy, "Upgraded")
-            .withArgs(upgradable.address);
+            .withArgs(upgradable.target);
         });
       });
     });