@gooddollar/goodprotocol 1.0.29-beta.4 → 1.0.29

package/test/ubi/UBIScheme.test.ts

@@ -127,11 +127,13 @@ 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();
@@ -198,26 +200,24 @@ describe("UBIScheme", () => {
     expect(error.message).to.have.string("Only UBIScheme can call this method");
   });
 
-  it("should estimate next daily UBI to according to min value when no claimers and not using first claim pool", async () => {
+  it("should estimate next daily UBI to default value when no claimers and not using first claim pool", async () => {
     const nextDailyUBIBefore = await ubi.estimateNextDailyUBI();
-    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
-    ]);
+    const defaultDailyUbi = await ubi.defaultDailyUbi();
+    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(defaultDailyClaim));
+    expect(nextDailyUBIAfter.eq(defaultDailyUbi));
 
-    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, "300002");
-    //ubi will have 902GD in pool so daily ubi is now 300002/1(cycle)/1000(min claimers) = 300
+    await goodDollar.mint(avatar, "901");
+    //ubi will have 902GD in pool so daily ubi is now 902/1(cycle)/3(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 299 (30002 - 300 /1 / 1000)  from the second day claimed in this test
-    expect(claimer1Balance.toString()).to.be.equal("599");
+    // 300 GD from first day and 201 from the second day claimed in this test
+    expect(claimer1Balance.toString()).to.be.equal("501");
   });
 
   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, "20000");
+    await goodDollar.mint(avatar, "20");
     await increaseTime(ONE_DAY);
     let ubiBalance = await goodDollar.balanceOf(ubi.address);
     let avatarBalance = await goodDollar.balanceOf(avatar);
-    let activeUsersCount = await ubi.minActiveUsers(); // await ubi.activeUsersCount();
+    let activeUsersCount = 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.minActiveUsers(); // await ubi.activeUsersCount();
+    let activeUsersCount = 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);
-    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)
+    // 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
     expect(claimer1Balance2.sub(claimer1Balance1).toString()).to.be.equal(
-      dailyCyclePool.div(activeUsersCount)
+      BN.from("948439324947").div(3)
     );
   });
 
@@ -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();
-    await goodDollar.mint(ubiNew.address, 1000);
-    const expectedDailyUbi = 1; // 1000 divided by minActiveUsers which is also 1000 by default
+    const defaultDailyUbi = await ubiNew.defaultDailyUbi();
+    await goodDollar.mint(ubiNew.address, defaultDailyUbi);
     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(expectedDailyUbi));
+    expect(claimerBalanceAfter.sub(claimerBalanceBefore).eq(defaultDailyUbi));
   });
 });

package/test/ubi/UBISchemeCycle.test.ts

@@ -125,13 +125,12 @@ 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
-    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
+    expect(
+      await goodDollar.balanceOf(claimer1.address).then(_ => _.toNumber())
+    ).to.be.equal(
+      1000 + 58593 //58 amount of new ubicycle
+    );
     const cycleEvent = transaction.events.find(
       e => e.event === "UBICycleCalculated"
     );
@@ -141,8 +140,7 @@ describe("UBIScheme cycle", () => {
     expect(
       await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
     ).to.be.equal(0); //new cycle started
-    //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);
+    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
   });
 
   it("should calculate cycle early if we can increase current daily pool", async () => {
@@ -179,7 +177,7 @@ describe("UBIScheme cycle", () => {
     //increase ubi pool balance
     let encoded = goodDollar.interface.encodeFunctionData("mint", [
       ubiScheme.address,
-      100
+      1000
     ]);
     await genericCall(goodDollar.address, encoded);
     let balance = await goodDollar.balanceOf(ubiScheme.address);

package/test/utils/AdminWallet.test.ts

@@ -39,19 +39,16 @@ describe("AdminWallet", () => {
       admin2,
       toWhitelist
     ] = signers.slice(10);
-    let { identity: id, nameService } = await createDAO();
-    identity = await ethers.getContractAt("IdentityV2", id);
+    let { identity: id } = await createDAO();
+    identity = await ethers.getContractAt("IIdentity", id);
 
     adminWallet = (await upgrades.deployProxy(
       await ethers.getContractFactory("AdminWallet"),
-      [[], nameService.address, signers[0].address, 1e10],
+      [[], signers[0].address, id],
       { kind: "uups" }
     )) as AdminWallet;
 
-    await identity.grantRole(
-      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("identity_admin")),
-      adminWallet.address
-    );
+    identity.addIdentityAdmin(adminWallet.address);
 
     toppingTimes = await adminWallet.toppingTimes();
     toppingAmount = await adminWallet.toppingAmount();
@@ -90,12 +87,6 @@ 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"
@@ -151,10 +142,7 @@ describe("AdminWallet", () => {
 
     await adminWallet
       .connect(admin2)
-      ["whitelist(address,string)"](
-        toWhitelist.address,
-        "did:test" + Math.random()
-      );
+      .whitelist(toWhitelist.address, "did:test" + Math.random());
     const newBalance = await ethers.provider.getBalance(admin2.address);
     expect(newBalance).to.be.gte(expectedTopping);
   });
@@ -166,9 +154,7 @@ 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(address,string)"](whitelisted.address, "did:test");
+    await adminWallet.connect(admin).whitelist(whitelisted.address, "did:test");
 
     expect(await identity.isWhitelisted(whitelisted.address)).to.true;
     await adminWallet.connect(admin).removeWhitelist(whitelisted.address);
@@ -178,14 +164,10 @@ 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(address,string)"](whitelisted.address, "did:test")
+      adminWallet.connect(stranger).whitelist(whitelisted.address, "did:test")
     ).revertedWith("Caller is not admin");
     expect(await identity.isWhitelisted(whitelisted.address)).to.false;
-    await adminWallet
-      .connect(admin)
-      ["whitelist(address,string)"](whitelisted.address, "did:test");
+    await adminWallet.connect(admin).whitelist(whitelisted.address, "did:test");
     expect(await identity.isWhitelisted(whitelisted.address)).to.true;
     await expect(
       adminWallet.connect(stranger).removeWhitelist(whitelisted.address)
@@ -263,24 +245,20 @@ describe("AdminWallet", () => {
 
   it("should whitelist user", async () => {
     expect(await identity.isWhitelisted(stranger2.address)).to.false;
-    await adminWallet
-      .connect(admin2)
-      ["whitelist(address,string)"](stranger2.address, "did:test3");
+    await adminWallet.connect(admin2).whitelist(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(address,string)"](stranger.address, "did:test")
+      adminWallet.connect(admin2).whitelist(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("not owner");
+    ).revertedWith("Ownable: caller is not the owner");
   });
 
   it("should allow owner to upgrade", async () => {