@gooddollar/goodprotocol 1.0.29-beta.0 → 1.0.29-beta.2

package/test/ubi/UBIScheme.test.ts

@@ -127,13 +127,11 @@ describe("UBIScheme", () => {
 
   it("should return zero entitlement before UBI started", async () => {
     let blockTimestamp = (await ethers.provider.getBlock("latest")).timestamp;
-    const timeInDay = (blockTimestamp % (ONE_DAY));
+    const timeInDay = blockTimestamp % ONE_DAY;
     // Move to before 12pm of the current day
     if (timeInDay > 12 * ONE_HOUR) {
       blockTimestamp += 12 * ONE_HOUR;
-      await ethers.provider.send("evm_setNextBlockTimestamp", [
-        blockTimestamp
-      ]);
+      await ethers.provider.send("evm_setNextBlockTimestamp", [blockTimestamp]);
       await ethers.provider.send("evm_mine", []);
     }
     const ubiNew = await deployNewUbi();
@@ -200,24 +198,26 @@ describe("UBIScheme", () => {
     expect(error.message).to.have.string("Only UBIScheme can call this method");
   });
 
-  it("should estimate next daily UBI to default value when no claimers and not using first claim pool", async () => {
+  it("should estimate next daily UBI to according to min value when no claimers and not using first claim pool", async () => {
     const nextDailyUBIBefore = await ubi.estimateNextDailyUBI();
-    const defaultDailyUbi = await ubi.defaultDailyUbi();
-    let encodedCall = ubi.interface.encodeFunctionData(
-      "setUseFirstClaimPool",
-      [false]
-    );
+    const minActiveUsers = await ubi.minActiveUsers();
+    const cycleLength = await ubi.cycleLength();
+    const pool = await goodDollar.balanceOf(ubi.address);
+    const dailyPool = pool.div(cycleLength);
+    const defaultDailyClaim = dailyPool.div(minActiveUsers);
+    let encodedCall = ubi.interface.encodeFunctionData("setUseFirstClaimPool", [
+      false
+    ]);
     await genericCall(ubi.address, encodedCall);
     const nextDailyUBIAfter = await ubi.estimateNextDailyUBI();
 
     expect(nextDailyUBIBefore.eq(0));
     expect(nextDailyUBIAfter.gt(nextDailyUBIBefore));
-    expect(nextDailyUBIAfter.eq(defaultDailyUbi));
+    expect(nextDailyUBIAfter.eq(defaultDailyClaim));
 
-    encodedCall = ubi.interface.encodeFunctionData(
-      "setUseFirstClaimPool",
-      [true]
-    );
+    encodedCall = ubi.interface.encodeFunctionData("setUseFirstClaimPool", [
+      true
+    ]);
     await genericCall(ubi.address, encodedCall);
   });
 
@@ -315,8 +315,8 @@ describe("UBIScheme", () => {
     await genericCall(ubi.address, encodedCall); // we should set cyclelength to one cause this tests was implemented according to it
     const currentDay = await ubi.currentDayInCycle().then(_ => _.toNumber());
     await increaseTime(ONE_DAY);
-    await goodDollar.mint(avatar, "901");
-    //ubi will have 902GD in pool so daily ubi is now 902/1(cycle)/3(claimers) = 300
+    await goodDollar.mint(avatar, "300002");
+    //ubi will have 902GD in pool so daily ubi is now 300002/1(cycle)/1000(min claimers) = 300
     await ubi.connect(claimer1).claim();
     await increaseTime(ONE_DAY);
     await goodDollar.mint(avatar, "1");
@@ -326,8 +326,8 @@ describe("UBIScheme", () => {
     let avatarBalance = await goodDollar.balanceOf(avatar);
     let claimer1Balance = await goodDollar.balanceOf(claimer1.address);
     expect(avatarBalance.toString()).to.be.equal("0");
-    // 300 GD from first day and 201 from the second day claimed in this test
-    expect(claimer1Balance.toString()).to.be.equal("501");
+    // 300 GD from first day and 299 (30002 - 300 /1 / 1000)  from the second day claimed in this test
+    expect(claimer1Balance.toString()).to.be.equal("599");
   });
 
   it("should return the reward value for entitlement user", async () => {
@@ -519,11 +519,11 @@ describe("UBIScheme", () => {
   });
 
   it("distribute formula should return correct value", async () => {
-    await goodDollar.mint(avatar, "20");
+    await goodDollar.mint(avatar, "20000");
     await increaseTime(ONE_DAY);
     let ubiBalance = await goodDollar.balanceOf(ubi.address);
     let avatarBalance = await goodDollar.balanceOf(avatar);
-    let activeUsersCount = await ubi.activeUsersCount();
+    let activeUsersCount = await ubi.minActiveUsers(); // await ubi.activeUsersCount();
     let claimer4BalanceBefore = await goodDollar.balanceOf(claimer2.address);
     await ubi.connect(claimer2).claim();
     let claimer4BalanceAfter = await goodDollar.balanceOf(claimer2.address);
@@ -539,7 +539,7 @@ describe("UBIScheme", () => {
     await increaseTime(ONE_DAY);
     let ubiBalance = await goodDollar.balanceOf(ubi.address);
     let avatarBalance = await goodDollar.balanceOf(avatar);
-    let activeUsersCount = await ubi.activeUsersCount();
+    let activeUsersCount = await ubi.minActiveUsers(); // await ubi.activeUsersCount();
     let claimer4BalanceBefore = await goodDollar.balanceOf(claimer2.address);
     await ubi.connect(claimer2).claim();
     let claimer4BalanceAfter = await goodDollar.balanceOf(claimer2.address);
@@ -565,12 +565,12 @@ describe("UBIScheme", () => {
     let claimer1Balance1 = await goodDollar.balanceOf(claimer1.address);
     // regular claim
     await ubi.connect(claimer1).claim();
-    const ubiGdBalance = await goodDollar.balanceOf(ubi.address);
     let claimer1Balance2 = await goodDollar.balanceOf(claimer1.address);
-    // there are 3 claimers and the total ubi balance after the minting include the previous balance and
-    // the dailyCyclePool is 948439324947 minting tokens. that divides into 3
+    let dailyCyclePool = await ubi.dailyCyclePool();
+    let activeUsersCount = await ubi.minActiveUsers(); // await ubi.activeUsersCount();
+    // the dailyCyclePool  divided by max(activeUser,minActiveUsers) should give the daily claim (diff between ubipool balances)
     expect(claimer1Balance2.sub(claimer1Balance1).toString()).to.be.equal(
-      BN.from("948439324947").div(3)
+      dailyCyclePool.div(activeUsersCount)
     );
   });
 
@@ -627,8 +627,8 @@ describe("UBIScheme", () => {
 
   it("should award first claimer with default value when not using first claim pool", async () => {
     const ubiNew = await deployNewUbi();
-    const defaultDailyUbi = await ubiNew.defaultDailyUbi();
-    await goodDollar.mint(ubiNew.address, defaultDailyUbi);
+    await goodDollar.mint(ubiNew.address, 1000);
+    const expectedDailyUbi = 1; // 1000 divided by minActiveUsers which is also 1000 by default
     await addWhitelisted(claimer8.address, "claimer8");
     const encodedCall = ubiNew.interface.encodeFunctionData(
       "setUseFirstClaimPool",
@@ -638,8 +638,8 @@ describe("UBIScheme", () => {
     const claimerBalanceBefore = await goodDollar.balanceOf(claimer8.address);
     await (await ubiNew.connect(claimer8).claim()).wait();
     const claimerBalanceAfter = await goodDollar.balanceOf(claimer8.address);
-    
+
     expect(claimerBalanceAfter.gt(claimerBalanceBefore));
-    expect(claimerBalanceAfter.sub(claimerBalanceBefore).eq(defaultDailyUbi));
+    expect(claimerBalanceAfter.sub(claimerBalanceBefore).eq(expectedDailyUbi));
   });
 });

package/test/ubi/UBISchemeCycle.test.ts

@@ -125,12 +125,13 @@ describe("UBIScheme cycle", () => {
     expect(
       await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
     ).to.be.equal(10); //10 days passed total
+
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait(); //claims in new ubi cycle
-    expect(
-      await goodDollar.balanceOf(claimer1.address).then(_ => _.toNumber())
-    ).to.be.equal(
-      1000 + 58593 //58 amount of new ubicycle
-    );
+    let dailyClaimAmount = (await ubiScheme.dailyCyclePool()).div(1000); //initialy we have by default min 1000 active users
+
+    expect(await goodDollar.balanceOf(claimer1.address)).to.be.equal(
+      dailyClaimAmount.add(1000)
+    ); //intial 10 from first claim pool + daily
     const cycleEvent = transaction.events.find(
       e => e.event === "UBICycleCalculated"
     );
@@ -140,7 +141,8 @@ describe("UBIScheme cycle", () => {
     expect(
       await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
     ).to.be.equal(0); //new cycle started
-    expect(cycleEvent.args.dailyUBIPool).to.be.equal(117187); //pool balance: (1000000 - 62500 given to first claimer) divided by 8 days - only first claimer got 62500 in first cycle
+    //intial balance on cycle start 1000000 - 125(one user that claimed) = 999875, divide by cycle length (8) = 124984
+    expect(cycleEvent.args.dailyUBIPool).to.be.equal(124984);
   });
 
   it("should calculate cycle early if we can increase current daily pool", async () => {
@@ -177,7 +179,7 @@ describe("UBIScheme cycle", () => {
     //increase ubi pool balance
     let encoded = goodDollar.interface.encodeFunctionData("mint", [
       ubiScheme.address,
-      1000
+      100
     ]);
     await genericCall(goodDollar.address, encoded);
     let balance = await goodDollar.balanceOf(ubiScheme.address);

package/test/utils/AdminWallet.test.ts

@@ -27,8 +27,8 @@ describe("AdminWallet", () => {
 
   before(async () => {
     signers = await ethers.getSigners();
+    founder = signers[0];
     [
-      founder,
       whitelisted,
       stranger,
       stranger2,
@@ -38,17 +38,20 @@ describe("AdminWallet", () => {
       admin,
       admin2,
       toWhitelist
-    ] = signers;
-    let { identity: id } = await createDAO();
-    identity = await ethers.getContractAt("IIdentity", id);
+    ] = signers.slice(10);
+    let { identity: id, nameService } = await createDAO();
+    identity = await ethers.getContractAt("IdentityV2", id);
 
     adminWallet = (await upgrades.deployProxy(
       await ethers.getContractFactory("AdminWallet"),
-      [[], signers[0].address, id],
+      [[], nameService.address, signers[0].address, 1e10],
       { kind: "uups" }
     )) as AdminWallet;
 
-    identity.addIdentityAdmin(adminWallet.address);
+    await identity.grantRole(
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("identity_admin")),
+      adminWallet.address
+    );
 
     toppingTimes = await adminWallet.toppingTimes();
     toppingAmount = await adminWallet.toppingAmount();
@@ -87,6 +90,12 @@ describe("AdminWallet", () => {
     });
   });
 
+  it("should have owner", async () => {
+    expect(
+      await adminWallet.hasRole(ethers.constants.HashZero, signers[0].address)
+    ).to.eq(true);
+  });
+
   it("should not top admin list when empty", async () => {
     await expect(adminWallet["topAdmins(uint256)"](0)).revertedWith(
       "Admin list is empty"
@@ -142,7 +151,10 @@ describe("AdminWallet", () => {
 
     await adminWallet
       .connect(admin2)
-      .whitelist(toWhitelist.address, "did:test" + Math.random());
+      ["whitelist(address,string)"](
+        toWhitelist.address,
+        "did:test" + Math.random()
+      );
     const newBalance = await ethers.provider.getBalance(admin2.address);
     expect(newBalance).to.be.gte(expectedTopping);
   });
@@ -154,7 +166,9 @@ describe("AdminWallet", () => {
 
   it("should allow admin to whitelist and remove whitelist", async () => {
     expect(await identity.isWhitelisted(whitelisted.address)).to.false;
-    await adminWallet.connect(admin).whitelist(whitelisted.address, "did:test");
+    await adminWallet
+      .connect(admin)
+      ["whitelist(address,string)"](whitelisted.address, "did:test");
 
     expect(await identity.isWhitelisted(whitelisted.address)).to.true;
     await adminWallet.connect(admin).removeWhitelist(whitelisted.address);
@@ -164,10 +178,14 @@ describe("AdminWallet", () => {
   it("should not allow non-admin to whitelist and remove whitelist", async () => {
     expect(await identity.isWhitelisted(whitelisted.address)).to.false;
     await expect(
-      adminWallet.connect(stranger).whitelist(whitelisted.address, "did:test")
+      adminWallet
+        .connect(stranger)
+        ["whitelist(address,string)"](whitelisted.address, "did:test")
     ).revertedWith("Caller is not admin");
     expect(await identity.isWhitelisted(whitelisted.address)).to.false;
-    await adminWallet.connect(admin).whitelist(whitelisted.address, "did:test");
+    await adminWallet
+      .connect(admin)
+      ["whitelist(address,string)"](whitelisted.address, "did:test");
     expect(await identity.isWhitelisted(whitelisted.address)).to.true;
     await expect(
       adminWallet.connect(stranger).removeWhitelist(whitelisted.address)
@@ -245,20 +263,24 @@ describe("AdminWallet", () => {
 
   it("should whitelist user", async () => {
     expect(await identity.isWhitelisted(stranger2.address)).to.false;
-    await adminWallet.connect(admin2).whitelist(stranger2.address, "did:test3");
+    await adminWallet
+      .connect(admin2)
+      ["whitelist(address,string)"](stranger2.address, "did:test3");
     expect(await identity.isWhitelisted(stranger2.address)).to.true;
   });
 
   it("should not allow whitelisting with existing did", async () => {
     await expect(
-      adminWallet.connect(admin2).whitelist(stranger.address, "did:test")
+      adminWallet
+        .connect(admin2)
+        ["whitelist(address,string)"](stranger.address, "did:test")
     ).revertedWith("DID already registered");
   });
 
   it("should not allow anyone to upgrade", async () => {
     await expect(
       adminWallet.connect(admin2).upgradeTo(adminWallet.address)
-    ).revertedWith("Ownable: caller is not the owner");
+    ).revertedWith("not owner");
   });
 
   it("should allow owner to upgrade", async () => {
@@ -268,6 +290,11 @@ describe("AdminWallet", () => {
     await expect(adminWallet.connect(founder).upgradeTo(newver.address)).not
       .reverted;
 
+    await upgrades.forceImport(
+      adminWallet.address,
+      await ethers.getContractFactory("AdminWallet"),
+      { kind: "uups" }
+    );
     await expect(
       upgrades.upgradeProxy(
         adminWallet.address,