@gooddollar/goodprotocol 1.0.31-beta.0 → 2.0.1

package/test/token/SuperGoodDollar.test.ts

@@ -0,0 +1,422 @@
+import hre, { ethers } from "hardhat";
+import { assert, expect } from "chai";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { Framework } from "@superfluid-finance/sdk-core";
+import TransferAndCallMockABI from "@gooddollar/goodcontracts/build/contracts/TransferAndCallMock.json";
+import { createDAO, deploySuperGoodDollar } from "../helpers";
+import { ISuperGoodDollar } from "../../types";
+
+let sf,
+  sfHost,
+  founder,
+  alice,
+  bob,
+  eve,
+  newHost,
+  identityMock,
+  receiverMock,
+  sgd, // stands for "SuperGoodDollar"
+  feesFormula10PctMock;
+
+const alotOfDollars = ethers.utils.parseEther("100000");
+const tenDollars = ethers.utils.parseEther("10");
+const oneDollar = ethers.utils.parseEther("1");
+const tenDollarsPerDay = "124378109452730"; // flowrate per second
+
+const initialState = async () => {};
+
+before(async function () {
+  //get accounts from hardhat
+  [founder, alice, bob, eve, newHost] = await ethers.getSigners();
+
+  let { sfContracts } = await createDAO();
+
+  sfHost = sfContracts.host;
+  // initialize sdk-core to get a framework handle for more convenient access to Superfluid functionality
+  sf = await Framework.create({
+    chainId: 4447,
+    provider: ethers.provider,
+    resolverAddress: sfContracts.resolver,
+    protocolReleaseVersion: "test"
+  });
+
+  // GoodDollar specific init
+  const FeesFormulaMockFactory = await ethers.getContractFactory(
+    "FeesFormulaMock",
+    founder
+  );
+
+  const feesFormula0PctMock = await FeesFormulaMockFactory.deploy(0);
+
+  feesFormula10PctMock = await FeesFormulaMockFactory.deploy(100000);
+
+  // the zero address is a placeholder for the dao contract
+  const IdentityMockFactory = await ethers.getContractFactory(
+    "IdentityMock",
+    founder
+  );
+  identityMock = await IdentityMockFactory.deploy(
+    "0x0000000000000000000000000000000000000000"
+  );
+
+  receiverMock = await new ethers.ContractFactory(
+    TransferAndCallMockABI.abi,
+    TransferAndCallMockABI.bytecode,
+    founder
+  ).deploy();
+
+  sgd = await deploySuperGoodDollar(sfContracts, [
+    "SuperGoodDollar",
+    "SGD",
+    0, // cap
+    feesFormula0PctMock.address,
+    identityMock.address,
+    receiverMock.address,
+    founder.address
+  ]);
+
+  await sgd.mint(founder.address, alotOfDollars);
+});
+
+describe("SuperGoodDollar", async function () {
+  it("check superfluid host", async () => {
+    expect(await sgd.getHost()).equal(sfHost);
+  });
+
+  it("check ERC20 metadata", async function () {
+    await loadFixture(initialState);
+    const symbol = await sgd.symbol();
+    const name = await sgd.name();
+    assert.equal(symbol, "SGD", "symbol mismatch");
+    assert.equal(name, "SuperGoodDollar", "name mismatch");
+  });
+
+  it("mint to alice", async function () {
+    await loadFixture(initialState);
+    await sgd.mint(alice.address, alotOfDollars);
+    const balAfter = await sgd.balanceOf(alice.address);
+
+    assert.equal(
+      balAfter.toString(),
+      alotOfDollars.toString(),
+      "wrong balance after mint"
+    );
+  });
+
+  it("do ERC20 transfer", async function () {
+    await loadFixture(initialState);
+    await sgd.mint(alice.address, tenDollars);
+    await sgd.connect(alice).transfer(bob.address, tenDollars);
+    const balAfter = await sgd.balanceOf(bob.address);
+
+    assert.equal(
+      balAfter.toString(),
+      tenDollars.toString(),
+      "wrong balance after transfer"
+    );
+  });
+
+  it("do ERC20 transferFrom", async function () {
+    await loadFixture(initialState);
+    await sgd.approve(alice.address, tenDollars);
+    await sgd
+      .connect(alice)
+      .transferFrom(founder.address, bob.address, tenDollars);
+    assert.equal(
+      (await sgd.balanceOf(bob.address)).toString(),
+      tenDollars.toString(),
+      "wrong balance after transferFrom"
+    );
+  });
+
+  it("start stream", async function () {
+    await loadFixture(initialState);
+    await sgd.mint(alice.address, alotOfDollars);
+
+    await sf.cfaV1
+      .createFlow({
+        superToken: sgd.address,
+        sender: alice.address,
+        receiver: bob.address,
+        flowRate: tenDollarsPerDay
+      })
+      .exec(alice);
+
+    const bobNetFlow = await sf.cfaV1.getNetFlow({
+      superToken: sgd.address,
+      account: bob.address,
+      providerOrSigner: ethers.provider
+    });
+
+    assert.equal(
+      bobNetFlow,
+      tenDollarsPerDay,
+      "bob net flowrate not as expected"
+    );
+  });
+
+  it("pauseable", async function () {
+    await loadFixture(initialState);
+    await sgd.connect(founder).pause();
+    await expect(sgd.transfer(bob.address, tenDollars)).revertedWith(
+      "Pausable: token transfer while paused"
+    );
+
+    await expect(
+      sf.cfaV1
+        .createFlow({
+          superToken: sgd.address,
+          sender: alice.address,
+          receiver: bob.address,
+          flowRate: tenDollarsPerDay
+        })
+        .exec(alice)
+    ).reverted;
+
+    await sgd.connect(founder).unpause();
+    await sgd.transfer(bob.address, tenDollars);
+  });
+
+  it("non-zero fees are applied", async function () {
+    await loadFixture(initialState);
+
+    await sgd.connect(founder).mint(alice.address, tenDollars);
+    await sgd.setFormula(feesFormula10PctMock.address);
+
+    await expect(
+      sgd.connect(alice).transfer(bob.address, tenDollars)
+    ).revertedWith("Not enough balance to pay TX fee");
+
+    // mint the extra amount needed for 10% fees
+    await sgd.mint(alice.address, oneDollar);
+    await sgd.connect(alice).transfer(bob.address, tenDollars);
+
+    // since the sender pays the fee, alice should have spent 11$ and bob received 10$
+    assert.equal(
+      (await sgd.balanceOf(alice.address)).toString(),
+      "0",
+      "alice: wrong balance after transfer"
+    );
+    assert.equal(
+      (await sgd.balanceOf(bob.address)).toString(),
+      tenDollars.toString(),
+      "bob: wrong balance after transfer"
+    );
+  });
+
+  it("non-zero fees are applied for transferFrom (verify override of _transferForm)", async function () {
+    await loadFixture(initialState);
+
+    await sgd.connect(founder).mint(alice.address, tenDollars);
+    await sgd.setFormula(feesFormula10PctMock.address);
+
+    await sgd.connect(alice).approve(founder.address, tenDollars.mul(2));
+
+    await expect(
+      sgd.connect(founder).transferFrom(alice.address, bob.address, tenDollars)
+    ).revertedWith("Not enough balance to pay TX fee");
+
+    // mint the extra amount needed for 10% fees
+    await sgd.connect(founder).mint(alice.address, oneDollar);
+    assert.equal(
+      (await sgd.balanceOf(alice.address)).toString(),
+      tenDollars.add(oneDollar).toString(),
+      "alice: wrong balance after mint"
+    );
+
+    await sgd
+      .connect(founder)
+      .transferFrom(alice.address, bob.address, tenDollars);
+
+    // since the sender pays the fee, alice should have spent 11$ and bob received 10$
+    assert.equal(
+      (await sgd.balanceOf(alice.address)).toString(),
+      "0",
+      "alice: wrong balance after transfer"
+    );
+    assert.equal(
+      (await sgd.balanceOf(bob.address)).toString(),
+      tenDollars.toString(),
+      "bob: wrong balance after transfer"
+    );
+  });
+
+  it("should not be able to initialize again", async () => {
+    await loadFixture(initialState);
+    await expect(
+      sgd["initialize(string,string,uint256,address,address,address,address)"](
+        "x",
+        "y",
+        1,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero
+      )
+    ).revertedWith("Initializable: contract is already initialized");
+
+    await expect(
+      sgd["initialize(address,uint8,string,string)"](
+        ethers.constants.AddressZero,
+        2,
+        "GD",
+        "GD"
+      )
+    ).revertedWith("Initializable: contract is not initializing");
+  });
+
+  it("update the GoodDollar logic", async function () {
+    await loadFixture(initialState);
+    const sgdProxiable = await ethers.getContractAt(
+      "UUPSProxiable",
+      sgd.address,
+      founder.signer
+    );
+
+    const auxCodeAddrBefore = await sgdProxiable.getCodeAddress();
+
+    const newLogic = await (
+      await ethers.getContractFactory("SuperGoodDollar", founder)
+    ).deploy(newHost.address);
+
+    await expect(
+      sgdProxiable.connect(eve).updateCode(newLogic.address)
+    ).revertedWith("not owner");
+
+    await sgdProxiable.connect(founder).updateCode(newLogic.address);
+
+    const auxCodeAddrAfter = await sgdProxiable.getCodeAddress();
+
+    assert.notEqual(
+      auxCodeAddrBefore,
+      auxCodeAddrAfter,
+      "code address unchanged"
+    );
+
+    expect(await sgd.getHost()).equal(newHost.address);
+    await expect(
+      sgd["initialize(string,string,uint256,address,address,address,address)"](
+        "x",
+        "y",
+        1,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero
+      )
+    ).revertedWith("Initializable: contract is already initialized");
+  });
+
+  describe("ERC20Permit", () => {
+    const name = "SuperGoodDollar";
+    const version = "1";
+
+    const Permit = [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "nonce", type: "uint256" },
+      { name: "deadline", type: "uint256" }
+    ];
+
+    it("initial nonce is 0", async function () {
+      expect(await sgd.nonces(alice.address)).to.equal(0);
+    });
+
+    it("domain separator", async function () {
+      const hashedDomain = await ethers.utils._TypedDataEncoder.hashDomain({
+        name,
+        version,
+        chainId: 4447,
+        verifyingContract: sgd.address
+      });
+      expect(await sgd.DOMAIN_SEPARATOR()).to.equal(hashedDomain);
+    });
+
+    describe("permit", function () {
+      const wallet = ethers.Wallet.createRandom();
+
+      const chainId = 4447;
+      const owner = wallet.address;
+      const value = 42;
+      const nonce = 0;
+      const maxDeadline = ethers.constants.MaxUint256;
+
+      const buildData = (
+        chainId,
+        verifyingContract,
+        deadline = maxDeadline
+      ) => ({
+        primaryType: "Permit",
+        types: { Permit },
+        domain: { name, version, chainId, verifyingContract },
+        message: { owner, spender: bob.address, value, nonce, deadline }
+      });
+
+      it("accepts owner signature", async function () {
+        const data = buildData(chainId, sgd.address);
+        const signature = await wallet._signTypedData(
+          data.domain,
+          data.types,
+          data.message
+        );
+        const { v, r, s } = ethers.utils.splitSignature(signature);
+
+        await sgd.permit(owner, bob.address, value, maxDeadline, v, r, s);
+
+        expect(await sgd.nonces(owner)).to.equal(1);
+        expect(await sgd.allowance(owner, bob.address)).to.equal(value);
+      });
+
+      it("rejects reused signature", async function () {
+        await loadFixture(initialState);
+
+        const data = buildData(chainId, sgd.address);
+        const signature = await wallet._signTypedData(
+          data.domain,
+          data.types,
+          data.message
+        );
+        const { v, r, s } = ethers.utils.splitSignature(signature);
+
+        await sgd.permit(owner, bob.address, value, maxDeadline, v, r, s);
+
+        await expect(
+          sgd.permit(owner, bob.address, value, maxDeadline, v, r, s)
+        ).revertedWith("ERC20Permit: invalid signature");
+      });
+
+      it("rejects other signature", async function () {
+        const otherWallet = ethers.Wallet.createRandom();
+        const data = buildData(chainId, sgd.address);
+        const signature = await otherWallet._signTypedData(
+          data.domain,
+          data.types,
+          data.message
+        );
+        const { v, r, s } = ethers.utils.splitSignature(signature);
+
+        await expect(
+          sgd.permit(owner, bob.address, value, maxDeadline, v, r, s)
+        ).revertedWith("ERC20Permit: invalid signature");
+      });
+
+      it("rejects expired permit", async function () {
+        const block = await ethers.provider.getBlock("latest");
+        const deadline = ethers.BigNumber.from(block.timestamp.toFixed(0));
+
+        const data = buildData(chainId, sgd.address, deadline);
+        const signature = await wallet._signTypedData(
+          data.domain,
+          data.types,
+          data.message
+        );
+        const { v, r, s } = ethers.utils.splitSignature(signature);
+
+        await expect(
+          sgd.permit(owner, bob.address, value, deadline, v, r, s)
+        ).revertedWith("ERC20Permit: expired deadline");
+      });
+    });
+  });
+});

package/test/ubi/UBIScheme.e2e.test.ts

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import {
   UBIScheme,
@@ -85,7 +86,7 @@ describe("UBIScheme - network e2e tests", () => {
     const goodCompoundStakingFactory = await getStakingFactory(
       "GoodCompoundStakingV2"
     );
-    const deployedDAO = await createDAO();
+    const deployedDAO = await loadFixture(createDAO);
     let {
       controller: ctrl,
       avatar: av,
@@ -160,8 +161,8 @@ describe("UBIScheme - network e2e tests", () => {
     const ubiScheme = await deployUBI(deployedDAO);
     ubi = ubiScheme.ubiScheme;
     firstClaimPool = ubiScheme.firstClaim;
-    setDAOAddress("CDAI", cDAI.address);
-    setDAOAddress("DAI", dai.address);
+    await setDAOAddress("CDAI", cDAI.address);
+    await setDAOAddress("DAI", dai.address);
     await goodReserve.setAddresses();
     const ictrl = await ethers.getContractAt(
       "Controller",
@@ -240,7 +241,7 @@ describe("UBIScheme - network e2e tests", () => {
       .fish(claimer.address)
       .catch(e => e);
     await goodDollar.balanceOf(fisherman.address);
-    expect(error.message).to.have.string("is not an inactive user");
+    expect(error.message).to.have.string("can't fish");
   });
 
   it("should be able to fish inactive user", async () => {
@@ -261,7 +262,7 @@ describe("UBIScheme - network e2e tests", () => {
       .connect(fisherman)
       .fish(claimer.address)
       .catch(e => e);
-    expect(error.message).to.have.string("already fished");
+    expect(error.message).to.have.string("can't fish");
   });
 
   it("should recieves a claim reward when call claim after being fished", async () => {

package/test/ubi/UBIScheme.test.ts

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { UBIScheme } from "../../types";
 import { createDAO, deployUBI, advanceBlocks, increaseTime } from "../helpers";
@@ -55,7 +56,7 @@ describe("UBIScheme", () => {
       FirstClaimPool.bytecode,
       (await ethers.getSigners())[0]
     );
-    const deployedDAO = await createDAO();
+    const deployedDAO = await loadFixture(createDAO);
     let {
       nameService: ns,
       genericCall: gn,
@@ -127,13 +128,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 +199,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);
   });
 
@@ -270,7 +271,7 @@ describe("UBIScheme", () => {
       .connect(fisherman)
       .fish(claimer1.address)
       .catch(e => e);
-    expect(error.message).to.have.string("is not an inactive user");
+    expect(error.message).to.have.string("can't fish");
   });
 
   it("should not initiate the scheme balance and distribution formula when a new user execute claim", async () => {
@@ -315,8 +316,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 +327,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 () => {
@@ -351,7 +352,7 @@ describe("UBIScheme", () => {
       .fish(claimer4.address)
       .catch(e => e);
     expect(isActiveUser).to.be.true;
-    expect(error.message).to.have.string("is not an inactive use");
+    expect(error.message).to.have.string("can't fish");
   });
 
   it("should not be able to execute claim twice a day", async () => {
@@ -413,7 +414,7 @@ describe("UBIScheme", () => {
       .catch(e => e);
     let isFishedAfter = await ubi.fishedUsersAddresses(claimer1.address);
     let claimer4BalanceAfter = await goodDollar.balanceOf(claimer4.address);
-    expect(error.message).to.have.string("already fished");
+    expect(error.message).to.have.string("can't fish");
     expect(isFishedBefore).to.be.true;
     expect(isFishedAfter).to.be.true;
     expect(claimer4BalanceAfter.toNumber()).to.be.equal(
@@ -452,7 +453,7 @@ describe("UBIScheme", () => {
       .catch(e => e);
     let isFishedAfter = await ubi.fishedUsersAddresses(claimer2.address);
     let claimer4BalanceAfter = await goodDollar.balanceOf(claimer4.address);
-    expect(error.message).to.have.string("is not an inactive user");
+    expect(error.message).to.have.string("can't fish");
     expect(isFishedBefore).to.be.false;
     expect(isFishedAfter).to.be.false;
     expect(claimer4BalanceAfter.toNumber()).to.be.equal(
@@ -519,11 +520,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 +540,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 +566,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)
     );
   });
 
@@ -610,7 +611,7 @@ describe("UBIScheme", () => {
       [200]
     );
 
-    genericCall(firstClaimPool.address, encodedCall);
+    await genericCall(firstClaimPool.address, encodedCall);
     const claimAmount = await firstClaimPool.claimAmount();
     expect(claimAmount.toString()).to.be.equal("200");
   });
@@ -627,8 +628,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 +639,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));
   });
 });