@gooddollar/goodprotocol 2.1.4 → 2.2.0

package/test/identity/IdentityV3.test.ts

@@ -16,16 +16,12 @@ describe("IdentityV3", () => {
 
   let avatar, gd: IGoodDollar, Controller, id: IIdentity;
 
+  const createDAOv3 = async () => {
+    return createDAO("super", "v3");
+  };
   before(async () => {
     [founder, ...signers] = await ethers.getSigners();
-    let {
-      controller,
-      avatar: av,
-      gd: gooddollar,
-      identity: idv2,
-      genericCall: gc
-    } = await loadFixture(createDAO);
-
+    let { controller, avatar: av, gd: gooddollar, identity: idv2, genericCall: gc } = await loadFixture(createDAOv3);
     genericCall = gc;
     identity = (await ethers.getContractAt("IdentityV3", idv2)) as IdentityV3;
     Controller = controller;
@@ -38,34 +34,24 @@ describe("IdentityV3", () => {
     //   ""
     // );
 
-    gd = (await ethers.getContractAt(
-      "IGoodDollar",
-      gooddollar,
-      founder
-    )) as IGoodDollar;
+    gd = (await ethers.getContractAt("IGoodDollar", gooddollar, founder)) as IGoodDollar;
   });
 
   it("should set DAO by creator", async () => {
     let f = await ethers.getContractFactory("IdentityV3");
-    let newid = (await upgrades.deployProxy(
-      f,
-      [signers[0].address, ethers.constants.AddressZero],
-      { kind: "uups" }
-    )) as IdentityV2;
+    let newid = (await upgrades.deployProxy(f, [signers[0].address, ethers.constants.AddressZero], {
+      kind: "uups"
+    })) as IdentityV3;
     expect(await newid.dao()).eq(ethers.constants.AddressZero);
-    await expect(
-      newid.connect(signers[0]).initDAO(await identity.nameService())
-    ).not.reverted;
+    await expect(newid.connect(signers[0]).initDAO(await identity.nameService())).not.reverted;
     expect(await newid.dao()).not.eq(ethers.constants.AddressZero);
   });
 
   it("should not be able to set DAO by non-creator", async () => {
     let f = await ethers.getContractFactory("IdentityV3");
-    let newid = (await upgrades.deployProxy(
-      f,
-      [signers[0].address, ethers.constants.AddressZero],
-      { kind: "uups" }
-    )) as IdentityV2;
+    let newid = (await upgrades.deployProxy(f, [signers[0].address, ethers.constants.AddressZero], {
+      kind: "uups"
+    })) as IdentityV3;
     expect(await newid.dao()).eq(ethers.constants.AddressZero);
     await expect(newid.initDAO(await identity.nameService())).reverted;
   });
@@ -96,43 +82,35 @@ describe("IdentityV3", () => {
 
     await identity.addWhitelisted(whitelisted.address);
 
-    const diffWhitelistedCount = (
-      (await identity.whitelistedCount()) as any
-    ).sub(oldWhitelistedCount);
+    const diffWhitelistedCount = ((await identity.whitelistedCount()) as any).sub(oldWhitelistedCount);
     expect(diffWhitelistedCount.toString()).to.be.equal("1");
 
     await identity.removeWhitelisted(whitelisted.address);
 
     const whitelistedCount = (await identity.whitelistedCount()) as any;
-    expect(whitelistedCount.toString()).to.be.equal(
-      oldWhitelistedCount.toString()
-    );
+    expect(whitelistedCount.toString()).to.be.equal(oldWhitelistedCount.toString());
   });
 
   it("should revert when non admin tries to add whitelisted", async () => {
     let whitelisted = signers[1];
-    await expect(
-      identity.connect(signers[2]).addWhitelisted(whitelisted.address)
-    ).revertedWith(/AccessControl: account/);
+    await expect(identity.connect(signers[2]).addWhitelisted(whitelisted.address)).revertedWith(
+      /AccessControl: account/
+    );
   });
 
   it("should revert when non admin tries to add blacklist", async () => {
     let blacklisted = signers[1];
-    await expect(
-      identity.connect(signers[2]).addBlacklisted(blacklisted.address)
-    ).revertedWith(/AccessControl: account/);
+    await expect(identity.connect(signers[2]).addBlacklisted(blacklisted.address)).revertedWith(
+      /AccessControl: account/
+    );
   });
 
   it("should revert when non admin tries to set the authentication period", async () => {
-    await expect(identity.connect(signers[2]).setAuthenticationPeriod(10))
-      .reverted;
+    await expect(identity.connect(signers[2]).setAuthenticationPeriod(10)).reverted;
   });
 
   it("should let owner set auth period", async () => {
-    const encoded = identity.interface.encodeFunctionData(
-      "setAuthenticationPeriod",
-      [10]
-    );
+    const encoded = identity.interface.encodeFunctionData("setAuthenticationPeriod", [10]);
     await genericCall(identity.address, encoded);
     expect(await identity.authenticationPeriod()).eq(10);
   });
@@ -148,9 +126,7 @@ describe("IdentityV3", () => {
 
   it("should revert when non admin tries to authentice a user", async () => {
     let authuser = signers[0].address;
-    await expect(
-      identity.connect(signers[2]).authenticate(authuser)
-    ).revertedWith(/AccessControl: account/);
+    await expect(identity.connect(signers[2]).authenticate(authuser)).revertedWith(/AccessControl: account/);
   });
 
   it("should authenticate the user with the correct timestamp", async () => {
@@ -167,18 +143,14 @@ describe("IdentityV3", () => {
   it("should add identity admin", async () => {
     let outsider = signers[5].address;
     await identity.grantRole(await identity.IDENTITY_ADMIN_ROLE(), outsider);
-    expect(
-      await identity.hasRole(await identity.IDENTITY_ADMIN_ROLE(), outsider)
-    ).true;
+    expect(await identity.hasRole(await identity.IDENTITY_ADMIN_ROLE(), outsider)).true;
   });
 
   it("should remove identity admin", async () => {
     let outsider = signers[5].address;
     await identity.revokeRole(await identity.IDENTITY_ADMIN_ROLE(), outsider);
 
-    expect(
-      await identity.hasRole(await identity.IDENTITY_ADMIN_ROLE(), outsider)
-    ).false;
+    expect(await identity.hasRole(await identity.IDENTITY_ADMIN_ROLE(), outsider)).false;
   });
 
   it("should revert when adding to whitelisted twice", async () => {
@@ -223,16 +195,14 @@ describe("IdentityV3", () => {
   it("should not allow adding with used did", async () => {
     let whitelisted2 = signers[2];
 
-    await expect(
-      identity.addWhitelistedWithDID(whitelisted2.address, "testString")
-    ).revertedWith(/DID already registered/);
+    await expect(identity.addWhitelistedWithDID(whitelisted2.address, "testString")).revertedWith(
+      /DID already registered/
+    );
   });
 
   it("should not allow adding non contract to contracts", async () => {
     let outsider = signers[0];
-    await expect(identity.addContract(outsider.address)).revertedWith(
-      /Given address is not a contract/
-    );
+    await expect(identity.addContract(outsider.address)).revertedWith(/Given address is not a contract/);
   });
 
   it("should add contract to contracts", async () => {
@@ -255,19 +225,13 @@ describe("IdentityV3", () => {
     const toconnect = signers[10];
     let whitelisted = signers[1];
 
-    expect(await identity.getWhitelistedRoot(toconnect.address)).eq(
-      ethers.constants.AddressZero
-    );
+    expect(await identity.getWhitelistedRoot(toconnect.address)).eq(ethers.constants.AddressZero);
 
     await loadFixture(connectedFixture);
 
-    expect(await identity.getWhitelistedRoot(whitelisted.address)).eq(
-      whitelisted.address
-    );
+    expect(await identity.getWhitelistedRoot(whitelisted.address)).eq(whitelisted.address);
 
-    expect(await identity.getWhitelistedRoot(toconnect.address)).eq(
-      whitelisted.address
-    );
+    expect(await identity.getWhitelistedRoot(toconnect.address)).eq(whitelisted.address);
   });
 
   it("should not allow to connect account already whitelisted", async () => {
@@ -276,9 +240,7 @@ describe("IdentityV3", () => {
     await identity.addWhitelisted(signers[2].address);
     let whitelisted = signers[1];
 
-    await expect(
-      identity.connect(whitelisted).connectAccount(signers[2].address)
-    ).revertedWith(/invalid account/);
+    await expect(identity.connect(whitelisted).connectAccount(signers[2].address)).revertedWith(/invalid account/);
   });
 
   it("should allow to disconnect account by owner or connected", async () => {
@@ -287,14 +249,10 @@ describe("IdentityV3", () => {
     const connected = signers[10];
     const whitelisted = signers[1];
     await identity.connect(connected).disconnectAccount(connected.address);
-    expect(await identity.getWhitelistedRoot(connected.address)).eq(
-      ethers.constants.AddressZero
-    );
+    expect(await identity.getWhitelistedRoot(connected.address)).eq(ethers.constants.AddressZero);
     await loadFixture(connectedFixture);
     await identity.connect(whitelisted).disconnectAccount(connected.address);
-    expect(await identity.getWhitelistedRoot(connected.address)).eq(
-      ethers.constants.AddressZero
-    );
+    expect(await identity.getWhitelistedRoot(connected.address)).eq(ethers.constants.AddressZero);
   });
 
   it("should not allow to disconnect account not by owner or by connected", async () => {
@@ -302,9 +260,7 @@ describe("IdentityV3", () => {
 
     const connected = signers[10];
     const whitelisted = signers[1];
-    await expect(identity.disconnectAccount(connected.address)).revertedWith(
-      /unauthorized/
-    );
+    await expect(identity.disconnectAccount(connected.address)).revertedWith(/unauthorized/);
   });
 
   it("should not allow to connect to an already connected account", async () => {
@@ -314,9 +270,7 @@ describe("IdentityV3", () => {
     expect(await identity.isWhitelisted(signers[2].address)).true;
     const connected = signers[10];
 
-    await expect(
-      identity.connect(signers[2]).connectAccount(connected.address)
-    ).revertedWith(/already connected/);
+    await expect(identity.connect(signers[2]).connectAccount(connected.address)).revertedWith(/already connected/);
   });
 
   it("should return same root for multiple connected accounts", async () => {
@@ -335,27 +289,19 @@ describe("IdentityV3", () => {
     const toWhitelist = signers[2];
 
     const ts = (Date.now() / 1000 - 100000).toFixed(0);
-    await identity.addWhitelistedWithDIDAndChain(
-      toWhitelist.address,
-      "xxx",
-      1234,
-      ts
-    );
+    await identity.addWhitelistedWithDIDAndChain(toWhitelist.address, "xxx", 1234, ts);
     const record = await identity.identities(toWhitelist.address);
     expect(record.whitelistedOnChainId).eq(1234);
     expect(record.dateAuthenticated).eq(ts);
   });
 
   const oldidFixture = async () => {
-    const newid = (await upgrades.deployProxy(
-      await ethers.getContractFactory("IdentityV3"),
-      [founder.address, identity.address]
-    )) as IdentityV3;
-
-    await identity.grantRole(
-      await identity.IDENTITY_ADMIN_ROLE(),
-      newid.address
-    );
+    const newid = (await upgrades.deployProxy(await ethers.getContractFactory("IdentityV3"), [
+      founder.address,
+      identity.address
+    ])) as IdentityV3;
+
+    await identity.grantRole(await identity.IDENTITY_ADMIN_ROLE(), newid.address);
     await identity.addBlacklisted(signers[4].address);
     await identity.addContract(identity.address);
     await identity.removeWhitelisted(signers[3].address);
@@ -365,9 +311,7 @@ describe("IdentityV3", () => {
 
   it("should default to old identity isWhitelisted, isBlacklisted, isContract", async () => {
     const { newid } = await loadFixture(oldidFixture);
-    expect(await (await identity.identities(signers[3].address)).did).eq(
-      "testolddid"
-    );
+    expect(await (await identity.identities(signers[3].address)).did).eq("testolddid");
     expect(await (await newid.identities(signers[3].address)).did).eq("");
 
     expect(await identity.addrToDID(signers[3].address)).eq("testolddid");
@@ -396,51 +340,31 @@ describe("IdentityV3", () => {
   it("should not set did if set in oldidentity", async () => {
     const { newid } = await loadFixture(oldidFixture);
 
-    await expect(
-      newid
-        .connect(signers[1])
-        ["setDID(address,string)"](signers[1].address, "testolddid")
-    ).revertedWith(/DID already registered oldIdentity/);
+    await expect(newid.connect(signers[1])["setDID(address,string)"](signers[1].address, "testolddid")).revertedWith(
+      /DID already registered oldIdentity/
+    );
   });
 
   it("should set did if set in oldidentity by same owner", async () => {
     const { newid } = await loadFixture(oldidFixture);
 
-    await expect(
-      newid
-        .connect(signers[3])
-        ["setDID(address,string)"](signers[3].address, "testolddid")
-    ).not.reverted;
+    await expect(newid.connect(signers[3])["setDID(address,string)"](signers[3].address, "testolddid")).not.reverted;
     expect(await newid.addrToDID(signers[3].address)).eq("testolddid");
   });
   it("should set did if set in oldidentity by different owner but updated in new identity", async () => {
     const { newid } = await loadFixture(oldidFixture);
 
-    await expect(
-      newid
-        .connect(signers[3])
-        ["setDID(address,string)"](signers[3].address, "newdid")
-    ).not.reverted;
+    await expect(newid.connect(signers[3])["setDID(address,string)"](signers[3].address, "newdid")).not.reverted;
     expect(await newid.addrToDID(signers[3].address)).eq("newdid");
 
-    await expect(
-      newid
-        .connect(signers[1])
-        ["setDID(address,string)"](signers[1].address, "testolddid")
-    ).not.reverted;
+    await expect(newid.connect(signers[1])["setDID(address,string)"](signers[1].address, "testolddid")).not.reverted;
     expect(await newid.addrToDID(signers[1].address)).eq("testolddid");
   });
 
   it("should let admin setDID", async () => {
-    await expect(
-      identity["setDID(address,string)"](signers[1].address, "admindid")
-    ).not.reverted;
+    await expect(identity["setDID(address,string)"](signers[1].address, "admindid")).not.reverted;
     expect(await identity.addrToDID(signers[1].address)).eq("admindid");
-    await expect(
-      identity
-        .connect(signers[2])
-        ["setDID(address,string)"](signers[1].address, "admindid")
-    ).reverted;
+    await expect(identity.connect(signers[2])["setDID(address,string)"](signers[1].address, "admindid")).reverted;
   });
 
   it("should be registered for v1 compatability", async () => {