@gooddollar/goodprotocol 1.0.7-beta.3 → 1.0.9

package/test/governance/GReputation.test.ts

@@ -7,6 +7,7 @@ import { expect } from "chai";
 import { GReputation } from "../../types";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
 import { advanceBlocks, createDAO, increaseTime } from "../helpers";
+import { TextDecoder } from "util";
 
 const BN = ethers.BigNumber;
 export const NULL_ADDRESS = ethers.constants.AddressZero;
@@ -130,7 +131,7 @@ describe("GReputation", () => {
   });
 
   it("should get balanceOf", async () => {
-    const repBalance = await grep.balanceOf(founder);
+    const repBalance = await grep.balanceOfLocal(founder);
     expect(repBalance.toNumber()).to.be.equal(0);
   });
 
@@ -162,7 +163,7 @@ describe("GReputation", () => {
       await grep.proveBalanceOfAtBlockchain("rootState", rep1, 1, proof, 1);
 
       //root states changes the core balance
-      const newRep = await grep.balanceOf(rep1);
+      const newRep = await grep.balanceOfLocal(rep1);
       expect(newRep.toNumber()).to.be.equal(1);
 
       const newVotes = await grep.getVotes(rep1);
@@ -199,10 +200,12 @@ describe("GReputation", () => {
 
   describe("delegation", async () => {
     it("should allow delegation", async () => {
-      expect(await grep.balanceOf(rep3)).to.be.eq(BN.from(0));
+      expect(await grep.balanceOfLocal(rep3)).to.be.eq(BN.from(0));
       await grep.connect(signers[2]).delegateTo(rep3); //rep1 -> rep3
 
-      expect(await grep.getVotes(rep3)).to.be.eq(await grep.balanceOf(rep1)); //with delegation
+      expect(await grep.getVotes(rep3)).to.be.eq(
+        await grep.balanceOfLocal(rep1)
+      ); //with delegation
       expect(
         await grep.getVotes(rep1),
         "delegator should now have 0 votes"
@@ -238,7 +241,7 @@ describe("GReputation", () => {
     });
 
     it("should allow to change delegate", async () => {
-      expect(await grep.balanceOf(rep1)).to.be.eq(BN.from(1)); //proof was submitted
+      expect(await grep.balanceOfLocal(rep1)).to.be.eq(BN.from(1)); //proof was submitted
       await grep.connect(signers[3]).delegateTo(rep1); //rep2 -> rep1
       expect(await grep.getVotes(rep3)).to.be.eq(BN.from(1)); //previous delegate should now be 1 bcause it has only rep1
       expect(await grep.getVotes(rep1)).to.be.eq(
@@ -251,10 +254,10 @@ describe("GReputation", () => {
 
     it("should allow undelegation", async () => {
       await grep.connect(signers[2]).undelegate(); //rep1 -> remove delegattion to rep3
-      expect(await grep.balanceOf(rep3)).to.be.eq(BN.from(0));
+      expect(await grep.balanceOfLocal(rep3)).to.be.eq(BN.from(0));
       expect(await grep.getVotes(rep3)).to.be.eq(BN.from(0));
       expect(await grep.getVotes(rep1)).to.be.eq(BN.from(3)); //rep2 delegating to rep1 + rep1 votes
-      expect(await grep.balanceOf(rep1)).to.be.eq(BN.from(1));
+      expect(await grep.balanceOfLocal(rep1)).to.be.eq(BN.from(1));
 
       expect(await grep.delegates(rep1)).to.be.eq(rep1);
     });
@@ -409,20 +412,30 @@ describe("GReputation", () => {
         ["fuse", "0x" + merkleRoot.toString("hex"), 200]
       );
 
+      const totalSupply = await grep.totalSupply();
       await expect(avatarGenericCall(grep.address, encodedCall)).to.not.be
         .reverted;
+      const totalAfterSupply = await grep.totalSupply();
+      expect(totalAfterSupply).to.eq(totalSupply.add(200));
+    });
+
+    it("should modify only local totalSupply on burn mint", async () => {
+      const totalSupply = await grep.totalSupply();
+      await grepWithOwner["mint(address,uint256)"](founder, 155);
+      const totalSupplyAfter = await grep.totalSupply();
+      expect(totalSupplyAfter).to.eq(totalSupply.add(155));
     });
 
     it("should not reset core balance", async () => {
       //before proving new rep in new root balance should be 0
-      const newRep = await grep.balanceOf(rep1);
+      const newRep = await grep.balanceOfLocal(rep1);
       expect(newRep.toNumber()).to.be.gt(0);
-      const newRep2 = await grep.balanceOf(rep2);
+      const newRep2 = await grep.balanceOfLocal(rep2);
       expect(newRep2.toNumber()).to.be.gt(0);
     });
 
     it("should prove balance in new state", async () => {
-      const prevRep = await grep.balanceOf(rep2);
+      const prevRep = await grep.balanceOfLocal(rep2);
       const prevVotes = await grep.getVotes(rep2);
       const { proof } = getMerkleAndProof(
         [
@@ -435,17 +448,29 @@ describe("GReputation", () => {
       );
 
       await grep.proveBalanceOfAtBlockchain("fuse", rep2, 200, proof, 2);
-      const newRep = await grep.balanceOf(rep2);
+      const newRep = await grep.balanceOfLocal(rep2);
       expect(newRep).to.be.equal(prevRep); //core rep should not change
       const newVotes = await grep.getVotes(rep2);
 
       expect(newVotes).to.be.equal(prevVotes.add(200));
     });
 
-    it("should allow delegation of new state balance", async () => {
+    it("should keep active votes (local balance) correctly after mint/burn", async () => {
+      await grep.connect(signers[3]).undelegate();
+      const totalSupply = await grep.getCurrentVotes(rep2);
+      const tx = await grepWithOwner["mint(address,uint256)"](rep2, 155);
+      const result = await tx.wait();
+      const totalSupplyAfter = await grep.getVotes(rep2);
+      expect(totalSupplyAfter).to.eq(totalSupply.add(155));
+    });
+
+    it("should only delegate core balance and not new state balance", async () => {
       expect(await grep.getVotes(rep3)).to.be.eq(BN.from(0));
       await grep.connect(signers[3]).delegateTo(rep3); //rep2=signers[3]
-      expect(await grep.getVotes(rep3)).to.be.eq(await grep.balanceOf(rep2));
+      expect(await grep.getVotes(rep3)).to.be.eq(
+        await grep.balanceOfLocal(rep2)
+      );
+      expect(await grep.getVotes(rep3)).to.be.lt(await grep.getVotes(rep2));
     });
 
     it("should not effect delegate balance after new state hash", async () => {
@@ -680,12 +705,18 @@ describe("GReputation", () => {
 
     it("it should be able to get totalSupply for particular block", async () => {
       let currentSupply = await grep["totalSupply()"]();
+      let localSupply = await grep.totalSupplyLocalAt(
+        await ethers.provider.getBlockNumber()
+      );
       await grepWithOwner["mint(address,uint256)"](
         founder,
         ethers.utils.parseEther("1")
       );
       let currentBlock = await ethers.provider.getBlockNumber();
-      let totalSupply = await grep.totalSupplyLocal(currentBlock);
+      let totalSupply = await grep.totalSupplyAt(currentBlock);
+      expect(await grep.totalSupplyLocalAt(currentBlock)).to.equal(
+        localSupply.add(ethers.utils.parseEther("1"))
+      );
       expect(
         totalSupply
           .sub(currentSupply)
@@ -785,11 +816,11 @@ describe("GReputation", () => {
       await grep.connect(signers[4]).setReputationRecipient(repTarget);
       expect(await grep.reputationRecipients(rep3)).to.equal(repTarget);
       await grepWithOwner.mint(rep3, 111);
-      expect(await grep.balanceOf(repTarget)).to.equal(111);
+      expect(await grep.balanceOfLocal(repTarget)).to.equal(111);
     });
 
     it("user should be able to unset recipient", async () => {
-      const startBalance = await grep.balanceOf(rep3);
+      const startBalance = await grep.balanceOfLocal(rep3);
       await grep
         .connect(signers[4])
         .setReputationRecipient(ethers.constants.AddressZero);
@@ -797,8 +828,8 @@ describe("GReputation", () => {
         ethers.constants.AddressZero
       );
       await grepWithOwner.mint(rep3, 111);
-      expect(await grep.balanceOf(repTarget)).to.equal(111);
-      expect(await grep.balanceOf(rep3)).to.equal(startBalance.add(111));
+      expect(await grep.balanceOfLocal(repTarget)).to.equal(111);
+      expect(await grep.balanceOfLocal(rep3)).to.equal(startBalance.add(111));
     });
   });
 });

package/test/governance/GovernanceStaking.test.ts

@@ -7,7 +7,7 @@ import {
   CERC20,
   GoodReserveCDai,
   SimpleStaking,
-  GReputation,
+  GReputation
 } from "../../types";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
 import { createDAO, increaseTime, advanceBlocks } from "../helpers";
@@ -64,7 +64,7 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
       cdaiAddress,
       reserve,
       reputation,
-      setReserveToken,
+      setReserveToken
     } = await createDAO();
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     cDAI = await ethers.getContractAt("cDAIMock", cdaiAddress);
@@ -79,7 +79,7 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
       gd,
       identity,
       controller,
-      avatar,
+      avatar
     });
     goodFundManager = await upgrades.deployProxy(
       goodFundManagerFactory,
@@ -91,7 +91,7 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
       reputation
     )) as GReputation;
     console.log("Deployed goodfund manager", {
-      manager: goodFundManager.address,
+      manager: goodFundManager.address
     });
     goodDollar = await ethers.getContractAt("IGoodDollar", gd);
     contribution = await ethers.getContractAt(
@@ -102,7 +102,7 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
     marketMaker = mm;
 
     console.log("deployed contribution, deploying reserve...", {
-      founder: founder.address,
+      founder: founder.address
     });
 
     console.log("setting permissions...");
@@ -125,7 +125,7 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
     await goodDollar.approve(governanceStaking.address, "100");
     await governanceStaking.stake("100");
     await advanceBlocks(5);
-    const error = await governanceStaking.withdrawStake("100").catch((e) => e);
+    const error = await governanceStaking.withdrawStake("100").catch(e => e);
     expect(error.message).to.have.string(
       "GReputation: need minter role or be GDAO contract"
     );
@@ -133,9 +133,11 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
 
   it("Should be able mint rewards after set GDAO staking contract", async () => {
     await setDAOAddress("GDAO_STAKING", governanceStaking.address);
-    const GDAOBalanceBeforeWithdraw = await grep.balanceOf(founder.address);
+    const GDAOBalanceBeforeWithdraw = await grep.balanceOfLocal(
+      founder.address
+    );
     await governanceStaking.withdrawStake("100");
-    const GDAOBalanceAfterWithdraw = await grep.balanceOf(founder.address);
+    const GDAOBalanceAfterWithdraw = await grep.balanceOfLocal(founder.address);
 
     expect(GDAOBalanceAfterWithdraw).to.gt(GDAOBalanceBeforeWithdraw);
   });
@@ -163,10 +165,12 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
     const stakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
     await governanceStaking.stake("100");
     await advanceBlocks(4);
-    const GDAOBalanceBeforeWithdraw = await grep.balanceOf(founder.address);
+    const GDAOBalanceBeforeWithdraw = await grep.balanceOfLocal(
+      founder.address
+    );
     await governanceStaking.withdrawStake("100");
     const withdrawBlockNumber = await ethers.provider.getBlockNumber();
-    const GDAOBalanceAfterWithdraw = await grep.balanceOf(founder.address);
+    const GDAOBalanceAfterWithdraw = await grep.balanceOfLocal(founder.address);
     const multiplier = withdrawBlockNumber - stakeBlockNumber;
     const calculatedReward = rewardsPerBlock.mul(multiplier); // We calculate user rewards since it's the only staker so gets whole rewards so rewardsPerBlock * multipler(block that passed between stake and withdraw)
     expect(GDAOBalanceAfterWithdraw).to.be.equal(
@@ -186,18 +190,20 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
     const stakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
     await governanceStaking.stake("100");
     await advanceBlocks(4);
-    const GDAOBalanceBeforeWithdraw = await grep.balanceOf(founder.address);
+    const GDAOBalanceBeforeWithdraw = await grep.balanceOfLocal(
+      founder.address
+    );
     const transaction = await (
       await governanceStaking.withdrawRewards()
     ).wait();
     const withdrawBlockNumber = await ethers.provider.getBlockNumber();
-    const GDAOBalanceAfterWithdraw = await grep.balanceOf(founder.address);
+    const GDAOBalanceAfterWithdraw = await grep.balanceOfLocal(founder.address);
     const multiplier = withdrawBlockNumber - stakeBlockNumber;
     const calculatedReward = rewardsPerBlock.mul(multiplier); // We calculate user rewards since it's the only staker so gets whole rewards so rewardsPerBlock * multipler(block that passed between stake and withdraw)
     expect(GDAOBalanceAfterWithdraw).to.be.equal(
       GDAOBalanceBeforeWithdraw.add(calculatedReward)
     );
-    expect(transaction.events.find((_) => _.event === "ReputationEarned")).to.be
+    expect(transaction.events.find(_ => _.event === "ReputationEarned")).to.be
       .not.empty;
     await governanceStaking.withdrawStake("100");
   });
@@ -209,9 +215,11 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
     await advanceBlocks(4);
     await governanceStaking.connect(staker).transfer(founder.address, "100");
     await governanceStaking.connect(staker).withdrawRewards();
-    const gdaoBalanceBeforeWithdraw = await grep.balanceOf(founder.address);
+    const gdaoBalanceBeforeWithdraw = await grep.balanceOfLocal(
+      founder.address
+    );
     await governanceStaking.withdrawStake("100");
-    const gdaoBalanceAfterWithdraw = await grep.balanceOf(founder.address);
+    const gdaoBalanceAfterWithdraw = await grep.balanceOfLocal(founder.address);
     expect(gdaoBalanceAfterWithdraw).to.gt(gdaoBalanceBeforeWithdraw);
   });
 
@@ -219,7 +227,7 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
     let transaction = await governanceStaking
       .connect(staker)
       .withdrawStake("100")
-      .catch((e) => e);
+      .catch(e => e);
     expect(transaction.message).to.have.string("Not enough token staked");
   });
 
@@ -243,10 +251,12 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
     const stakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
     await governanceStaking.stake("100");
     await advanceBlocks(4);
-    const GDAOBalanceBeforeWithdraw = await grep.balanceOf(founder.address);
+    const GDAOBalanceBeforeWithdraw = await grep.balanceOfLocal(
+      founder.address
+    );
     await governanceStaking.withdrawStake("100");
     const withdrawBlockNumber = await ethers.provider.getBlockNumber();
-    const GDAOBalanceAfterWithdraw = await grep.balanceOf(founder.address);
+    const GDAOBalanceAfterWithdraw = await grep.balanceOfLocal(founder.address);
     const multiplier = withdrawBlockNumber - stakeBlockNumber;
     const calculatedReward = rewardsPerBlock.mul(multiplier); // We calculate user rewards since it's the only staker so gets whole rewards so rewardsPerBlock * multipler(block that passed between stake and withdraw)
     expect(GDAOBalanceAfterWithdraw).to.be.equal(
@@ -277,9 +287,11 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
     ](founder.address);
     expect(userProductivity[0]).to.be.equal(BN.from("100"));
     await advanceBlocks(4);
-    const GDAOBalanceBeforeWithdraw = await grep.balanceOf(founder.address);
+    const GDAOBalanceBeforeWithdraw = await grep.balanceOfLocal(
+      founder.address
+    );
     await governanceStaking.withdrawStake("100");
-    const GDAOBalanceAfterWithdraw = await grep.balanceOf(founder.address);
+    const GDAOBalanceAfterWithdraw = await grep.balanceOfLocal(founder.address);
     expect(GDAOBalanceAfterWithdraw.sub(GDAOBalanceBeforeWithdraw)).to.equal(0);
     encodedCall = governanceStakingFactory.interface.encodeFunctionData(
       "setMonthlyRewards",
@@ -325,10 +337,12 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
     const stakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
     await governanceStaking.stake("1000000000000");
     await advanceBlocks(4);
-    const GDAOBalanceBeforeWithdraw = await grep.balanceOf(founder.address);
+    const GDAOBalanceBeforeWithdraw = await grep.balanceOfLocal(
+      founder.address
+    );
     await governanceStaking.withdrawStake("1000000000000");
     const withdrawBlockNumber = await ethers.provider.getBlockNumber();
-    const GDAOBalanceAfterWithdraw = await grep.balanceOf(founder.address);
+    const GDAOBalanceAfterWithdraw = await grep.balanceOfLocal(founder.address);
     const multiplier = withdrawBlockNumber - stakeBlockNumber;
     const calculatedReward = rewardsPerBlock.mul(multiplier); // We calculate user rewards since it's the only staker so gets whole rewards so rewardsPerBlock * multipler(block that passed between stake and withdraw)
     expect(GDAOBalanceAfterWithdraw).to.be.equal(
@@ -347,15 +361,15 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
       (await ethers.provider.getBlockNumber()) + 1;
     await governanceStaking.connect(staker).stake("200");
     await advanceBlocks(4);
-    const GDAOBalanceBeforeWithdraw = await grep.balanceOf(staker.address);
-    const FounderGDAOBalanceBeforeWithdraw = await grep.balanceOf(
+    const GDAOBalanceBeforeWithdraw = await grep.balanceOfLocal(staker.address);
+    const FounderGDAOBalanceBeforeWithdraw = await grep.balanceOfLocal(
       founder.address
     );
     await governanceStaking.withdrawStake("800");
     const founderWithdrawBlockNumber = await ethers.provider.getBlockNumber();
     await governanceStaking.connect(staker).withdrawStake("200");
-    const GDAOBalanceAfterWithdraw = await grep.balanceOf(staker.address);
-    const FounderGDAOBalanceAfterWithdraw = await grep.balanceOf(
+    const GDAOBalanceAfterWithdraw = await grep.balanceOfLocal(staker.address);
+    const FounderGDAOBalanceAfterWithdraw = await grep.balanceOfLocal(
       founder.address
     );
     const founderCalculatedRewards = rewardsPerBlock.add(
@@ -558,7 +572,7 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
   });
 
   it("Stake amount should be positive", async () => {
-    const tx = await governanceStaking.stake("0").catch((e) => e);
+    const tx = await governanceStaking.stake("0").catch(e => e);
     expect(tx.message).to.have.string(
       "You need to stake a positive token amount"
     );
@@ -567,7 +581,7 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
   it("It should approve stake amount in order to stake", async () => {
     const tx = await governanceStaking
       .stake(ethers.utils.parseEther("10000000"))
-      .catch((e) => e);
+      .catch(e => e);
     expect(tx.message).not.to.be.empty;
   });
 
@@ -594,10 +608,14 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
     const stakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
     await governanceStaking.stake("100");
     await advanceBlocks(5);
-    const gdaoBalanceBeforeGetRewards = await grep.balanceOf(founder.address);
+    const gdaoBalanceBeforeGetRewards = await grep.balanceOfLocal(
+      founder.address
+    );
     await governanceStaking.stake("100");
     const getRewardsBlockNumber = await ethers.provider.getBlockNumber();
-    const gdaoBalanceAfterGetRewards = await grep.balanceOf(founder.address);
+    const gdaoBalanceAfterGetRewards = await grep.balanceOfLocal(
+      founder.address
+    );
     const multiplier = getRewardsBlockNumber - stakeBlockNumber;
     const calculatedReward = rewardsPerBlock.mul(multiplier); // We calculate user rewards since it's the only staker so gets whole rewards so rewardsPerBlock * multipler(block that passed between stake and withdraw)
     await governanceStaking.withdrawStake("200");
@@ -624,43 +642,45 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
       .connect(signers[1])
       .approve(governanceStaking.address, stakingAmount);
     await governanceStaking.stake(stakingAmount);
-    const stakerOneGDAOBalanceAfterStake = await grep.balanceOf(
+    const stakerOneGDAOBalanceAfterStake = await grep.balanceOfLocal(
       founder.address
     );
     await governanceStaking.connect(staker).stake(stakingAmount.div(10));
-    const stakerTwoGDAOBalanceAfterStake = await grep.balanceOf(staker.address);
+    const stakerTwoGDAOBalanceAfterStake = await grep.balanceOfLocal(
+      staker.address
+    );
     await governanceStaking.connect(signers[0]).stake(stakingAmount.div(4));
-    const stakerThreeGDAOBalanceAfterStake = await grep.balanceOf(
+    const stakerThreeGDAOBalanceAfterStake = await grep.balanceOfLocal(
       signers[0].address
     );
     const stakerFourStakeBlockNumber =
       (await ethers.provider.getBlockNumber()) + 1;
     await governanceStaking.connect(signers[1]).stake(stakingAmount.div(5));
-    const stakerFourGDAOBalanceAfterStake = await grep.balanceOf(
+    const stakerFourGDAOBalanceAfterStake = await grep.balanceOfLocal(
       signers[1].address
     );
     await advanceBlocks(10);
     await governanceStaking.withdrawStake(stakingAmount);
     const stakerOneWithdrawBlockNumber = await ethers.provider.getBlockNumber();
-    const stakerOneGDAOBalanceAfterWithdraw = await grep.balanceOf(
+    const stakerOneGDAOBalanceAfterWithdraw = await grep.balanceOfLocal(
       founder.address
     );
     await governanceStaking
       .connect(staker)
       .withdrawStake(stakingAmount.div(10));
-    const stakerTwoGDAOBalanceAfterWithdraw = await grep.balanceOf(
+    const stakerTwoGDAOBalanceAfterWithdraw = await grep.balanceOfLocal(
       staker.address
     );
     await governanceStaking
       .connect(signers[0])
       .withdrawStake(stakingAmount.div(4));
-    const stakerThreeGDAOBalanceAfterWithdraw = await grep.balanceOf(
+    const stakerThreeGDAOBalanceAfterWithdraw = await grep.balanceOfLocal(
       signers[0].address
     );
     await governanceStaking
       .connect(signers[1])
       .withdrawStake(stakingAmount.div(5));
-    const stakerFourGDAOBalanceAfterWithdraw = await grep.balanceOf(
+    const stakerFourGDAOBalanceAfterWithdraw = await grep.balanceOfLocal(
       signers[1].address
     );
     const stakerOneRewardsCalculated = rewardsPerBlock
@@ -729,13 +749,15 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
       .connect(staker)
       .approve(governanceStaking.address, stakingAmount);
     await governanceStaking.stake(stakingAmount);
-    const stakerOneGDAOBalanceAfterStake = await grep.balanceOf(
+    const stakerOneGDAOBalanceAfterStake = await grep.balanceOfLocal(
       founder.address
     );
     const stakerTwoStakeBlockNumber =
       (await ethers.provider.getBlockNumber()) + 1;
     await governanceStaking.connect(staker).stake(stakingAmount.div(10000));
-    const stakerTwoGDAOBalanceAfterStake = await grep.balanceOf(staker.address);
+    const stakerTwoGDAOBalanceAfterStake = await grep.balanceOfLocal(
+      staker.address
+    );
     await advanceBlocks(10);
 
     await governanceStaking
@@ -744,10 +766,10 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
     const stakerTwoWithdrawBlockNumber = await ethers.provider.getBlockNumber();
     await governanceStaking.withdrawStake(stakingAmount);
 
-    const stakerOneGDAOBalanceAfterWithdraw = await grep.balanceOf(
+    const stakerOneGDAOBalanceAfterWithdraw = await grep.balanceOfLocal(
       founder.address
     );
-    const stakerTwoGDAOBalanceAfterWithdraw = await grep.balanceOf(
+    const stakerTwoGDAOBalanceAfterWithdraw = await grep.balanceOfLocal(
       staker.address
     );
     const calculatedRewardsStakerOne = rewardsPerBlock
@@ -785,11 +807,11 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
 
     const stakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
     await simpleGovernanceStaking.stake("200");
-    const GDAOBalanceAfterStake = await grep.balanceOf(founder.address);
+    const GDAOBalanceAfterStake = await grep.balanceOfLocal(founder.address);
     await advanceBlocks(100);
     await simpleGovernanceStaking.withdrawRewards();
     const withdrawRewardsBlockNumber = await ethers.provider.getBlockNumber();
-    const GDAOBalanceAfterWithdraw = await grep.balanceOf(founder.address);
+    const GDAOBalanceAfterWithdraw = await grep.balanceOfLocal(founder.address);
 
     expect(GDAOBalanceAfterWithdraw).to.be.equal(
       GDAOBalanceAfterStake.add(
@@ -819,18 +841,20 @@ describe("GovernanceStaking - staking with GD  and get Rewards in GDAO", () => {
     const rewardsPerBlock = await simpleGovernanceStaking.getRewardsPerBlock();
     const stakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
     await overMintTester.stake();
-    const GDAOBalanceAfterStake = await grep.balanceOf(overMintTester.address);
+    const GDAOBalanceAfterStake = await grep.balanceOfLocal(
+      overMintTester.address
+    );
     await advanceBlocks(100);
     await overMintTester.overMintTest();
     const withdrawRewardsBlockNumber = await ethers.provider.getBlockNumber();
-    const GDAOBalanceAfterWithdrawReward = await grep.balanceOf(
+    const GDAOBalanceAfterWithdrawReward = await grep.balanceOfLocal(
       overMintTester.address
     );
     await advanceBlocks(20);
     await overMintTester.overMintTest();
     const secondWithdrawRewardsBlockNumber =
       await ethers.provider.getBlockNumber();
-    const GDAOBalanceAfterSecondWithdrawReward = await grep.balanceOf(
+    const GDAOBalanceAfterSecondWithdrawReward = await grep.balanceOfLocal(
       overMintTester.address
     );