@gooddollar/goodprotocol 1.0.7 → 1.0.8

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
     );
 

package/test/governance/Reputation.test.ts

@@ -31,7 +31,7 @@ describe("Reputation", () => {
     let value;
     await reputation.mint(acct.address, 3131);
 
-    value = await reputation.balanceOf(acct.address);
+    value = await reputation.balanceOfLocal(acct.address);
     expect(value).to.equal(3131);
   });
 
@@ -50,10 +50,10 @@ describe("Reputation", () => {
     await expect(reputation.connect(signers[2]).mint(signers[2], 1000)).to
       .reverted;
 
-    let account0Rep = await reputation.balanceOf(signers[0].address);
-    let account1Rep = await reputation.balanceOf(signers[1].address);
-    let account2Rep = await reputation.balanceOf(signers[2].address);
-    let totalRep = await reputation.totalSupply();
+    let account0Rep = await reputation.balanceOfLocal(signers[0].address);
+    let account1Rep = await reputation.balanceOfLocal(signers[1].address);
+    let account2Rep = await reputation.balanceOfLocal(signers[2].address);
+    let totalRep = await reputation.totalSupplyLocal();
 
     expect(account1Rep).to.equal(1000, "account 1 reputation should be 1000");
     expect(account2Rep).to.equal(0, "account 2 reputation should be 0");
@@ -71,9 +71,9 @@ describe("Reputation", () => {
     await reputation.mint(signers[2].address, 3000);
 
     // this tx should have no effect
-    let account0Rep = await reputation.balanceOf(signers[0].address);
-    let account1Rep = await reputation.balanceOf(signers[1].address);
-    let account2Rep = await reputation.balanceOf(signers[2].address);
+    let account0Rep = await reputation.balanceOfLocal(signers[0].address);
+    let account1Rep = await reputation.balanceOfLocal(signers[1].address);
+    let account2Rep = await reputation.balanceOfLocal(signers[2].address);
 
     // expect(account0Rep, 2001, "account 0 reputation should be 2000");
     expect(account1Rep).to.equal(
@@ -82,7 +82,7 @@ describe("Reputation", () => {
     );
     expect(account2Rep).to.equal(3000, "account 2 reputation should be 3000");
 
-    let totalRep = await reputation.totalSupply();
+    let totalRep = await reputation.totalSupplyLocal();
 
     expect(totalRep).to.equal(
       account0Rep.add(account1Rep).add(account2Rep),
@@ -96,23 +96,22 @@ describe("Reputation", () => {
       .catch(e => e);
     expect(tx.message).to.have.string("Reputation: need minter role");
   });
-  it("user should be able to burn their own reputation",async()=>{
-    await reputation.connect(signers[0]).burn(signers[0].address, ethers.utils.parseEther("1"))
-  })
+  it("user should be able to burn their own reputation", async () => {
+    await reputation
+      .connect(signers[0])
+      .burn(signers[0].address, ethers.utils.parseEther("1"));
+  });
   it("check total reputation overflow", async () => {
     let BigNumber = ethers.BigNumber;
-    let bigNum = BigNumber.from(2)
-      .pow(128)
-      .sub(1)
-      .toString();
+    let bigNum = BigNumber.from(2).pow(128).sub(1).toString();
 
     await reputation.mint(signers[0].address, bigNum);
 
-    let totalRepBefore = await reputation.totalSupply();
+    let totalRepBefore = await reputation.totalSupplyLocal();
 
     await expect(reputation.mint(signers[1].address, 1)).to.reverted;
 
-    let totalRepAfter = await reputation.totalSupply();
+    let totalRepAfter = await reputation.totalSupplyLocal();
 
     expect(totalRepBefore).to.equal(totalRepAfter);
   });
@@ -122,15 +121,15 @@ describe("Reputation", () => {
     await reputation.mint(signers[1].address, 1500);
     await reputation.burn(signers[1].address, 500);
 
-    value = await reputation.balanceOf(signers[1].address);
-    let totalRepSupply = await reputation.totalSupply();
+    value = await reputation.balanceOfLocal(signers[1].address);
+    let totalRepSupply = await reputation.totalSupplyLocal();
 
     expect(value).to.equal(1000);
     expect(totalRepSupply).to.equal(1000);
   });
 
   it("totalSupply is 0 on init", async () => {
-    const totalSupply = await reputation.totalSupply();
+    const totalSupply = await reputation.totalSupplyLocal();
 
     expect(totalSupply).to.equal(0);
   });
@@ -163,12 +162,12 @@ describe("Reputation", () => {
 
   it("mint (plus) should be reflected in totalSupply", async () => {
     await reputation.mint(signers[1].address, 1000);
-    let totalSupply = await reputation.totalSupply();
+    let totalSupply = await reputation.totalSupplyLocal();
 
     expect(totalSupply).to.equal(1000);
 
     await reputation.mint(signers[2].address, 500);
-    totalSupply = await reputation.totalSupply();
+    totalSupply = await reputation.totalSupplyLocal();
 
     expect(totalSupply).to.equal(1500);
   });
@@ -176,22 +175,22 @@ describe("Reputation", () => {
   it("mint (plus) should be reflected in balances", async () => {
     await reputation.mint(signers[1].address, 1000);
 
-    const amount = await reputation.balanceOf(signers[1].address);
+    const amount = await reputation.balanceOfLocal(signers[1].address);
 
     expect(amount).to.equal(1000);
   });
 
   it("mint (minus) should be reflected in totalSupply", async () => {
     await reputation.mint(signers[1].address, 1000);
-    let totalSupply = await reputation.totalSupply();
+    let totalSupply = await reputation.totalSupplyLocal();
     expect(totalSupply).to.equal(1000);
 
     await reputation.burn(signers[1].address, 500);
-    totalSupply = await reputation.totalSupply();
+    totalSupply = await reputation.totalSupplyLocal();
     expect(totalSupply).to.equal(500);
 
     await reputation.burn(signers[1].address, 700);
-    totalSupply = await reputation.totalSupply();
+    totalSupply = await reputation.totalSupplyLocal();
     expect(totalSupply).to.equal(0);
   });
 
@@ -199,31 +198,31 @@ describe("Reputation", () => {
     await reputation.mint(signers[1].address, 1000);
     await reputation.burn(signers[1].address, 500);
 
-    let amount = await reputation.balanceOf(signers[1].address);
+    let amount = await reputation.balanceOfLocal(signers[1].address);
 
     expect(amount).to.equal(500);
 
     await reputation.burn(signers[1].address, 700);
-    amount = await reputation.balanceOf(signers[1].address);
+    amount = await reputation.balanceOfLocal(signers[1].address);
     expect(amount).to.equal(0);
   });
 
   it("account balance cannot be negative", async () => {
     await reputation.mint(signers[1].address, 1);
 
-    let amount = await reputation.balanceOf(signers[1].address);
+    let amount = await reputation.balanceOfLocal(signers[1].address);
     expect(amount).to.equal(1);
     await reputation.burn(signers[1].address, 2);
-    let rep = await reputation.balanceOf(signers[1].address);
+    let rep = await reputation.balanceOfLocal(signers[1].address);
     expect(rep).to.equal(0);
   });
 
   it("totalSupply cannot be negative", async () => {
     await reputation.mint(signers[1].address, 1);
-    let amount = await reputation.totalSupply();
+    let amount = await reputation.totalSupplyLocal();
     expect(amount).to.equal(1);
     await reputation.burn(signers[1].address, 2);
-    let rep = await reputation.totalSupply();
+    let rep = await reputation.totalSupplyLocal();
     expect(rep).to.equal(0);
   });
 
@@ -236,9 +235,9 @@ describe("Reputation", () => {
     await reputation.mint(signers[2].address, rep2);
     await reputation.mint(signers[3].address, rep3);
 
-    const balanceOf1 = await reputation.balanceOf(signers[1].address);
-    const balanceOf2 = await reputation.balanceOf(signers[2].address);
-    const balanceOf3 = await reputation.balanceOf(signers[3].address);
+    const balanceOf1 = await reputation.balanceOfLocal(signers[1].address);
+    const balanceOf2 = await reputation.balanceOfLocal(signers[2].address);
+    const balanceOf3 = await reputation.balanceOfLocal(signers[3].address);
 
     expect(balanceOf1).to.equal(rep1);
     expect(balanceOf2).to.equal(rep2);
@@ -250,19 +249,21 @@ describe("Reputation", () => {
     await reputation.mint(signers[1].address, rep1);
     var tx = await (await reputation.mint(signers[1].address, rep1)).wait();
     await reputation.mint(signers[3].address, rep1);
-    expect(await reputation.totalSupply()).to.equal(rep1 + rep1 + rep1);
-    expect(await reputation.totalSupplyAt(tx.blockNumber)).to.equal(
+    expect(await reputation.totalSupplyLocal()).to.equal(rep1 + rep1 + rep1);
+    expect(await reputation.totalSupplyLocalAt(tx.blockNumber)).to.equal(
       rep1 + rep1
     );
-    expect(await reputation.totalSupplyAt(tx.blockNumber - 1)).to.equal(rep1);
+    expect(await reputation.totalSupplyLocalAt(tx.blockNumber - 1)).to.equal(
+      rep1
+    );
     expect(
-      await reputation.balanceOfAt(signers[1].address, tx.blockNumber)
+      await reputation.balanceOfLocalAt(signers[1].address, tx.blockNumber)
     ).to.equal(rep1 + rep1);
     expect(
-      await reputation.balanceOfAt(signers[1].address, tx.blockNumber - 1)
+      await reputation.balanceOfLocalAt(signers[1].address, tx.blockNumber - 1)
     ).to.equal(rep1);
     expect(
-      await reputation.balanceOfAt(signers[3].address, tx.blockNumber)
+      await reputation.balanceOfLocalAt(signers[3].address, tx.blockNumber)
     ).to.equal(0);
   });
 
@@ -281,28 +282,28 @@ describe("Reputation", () => {
     var times = 3;
 
     await reputationTestHelper.multipleMint(signers[1].address, rep, times);
-    expect(await reputation.totalSupply()).to.equal(rep * times);
-    expect(await reputation.balanceOf(signers[1].address)).to.equal(
+    expect(await reputation.totalSupplyLocal()).to.equal(rep * times);
+    expect(await reputation.balanceOfLocal(signers[1].address)).to.equal(
       rep * times
     );
 
     await reputationTestHelper.multipleBurn(signers[1].address, rep, 2);
-    expect(await reputation.totalSupply()).to.equal(rep);
-    expect(await reputation.balanceOf(signers[1].address)).to.equal(rep);
+    expect(await reputation.totalSupplyLocal()).to.equal(rep);
+    expect(await reputation.balanceOfLocal(signers[1].address)).to.equal(rep);
   });
 
   it("balanceOfAt before first mint should be 0 ", async () => {
     const rep1 = Math.floor(Math.random() * 1e6);
     var tx = await (await reputation.mint(signers[1].address, rep1)).wait();
-    expect(await reputation.totalSupply()).to.equal(rep1);
-    expect(await reputation.totalSupplyAt(tx.blockNumber)).to.equal(rep1);
-    expect(await reputation.totalSupplyAt(tx.blockNumber - 1)).to.equal(0);
+    expect(await reputation.totalSupplyLocal()).to.equal(rep1);
+    expect(await reputation.totalSupplyLocalAt(tx.blockNumber)).to.equal(rep1);
+    expect(await reputation.totalSupplyLocalAt(tx.blockNumber - 1)).to.equal(0);
 
     expect(
-      await reputation.balanceOfAt(signers[1].address, tx.blockNumber)
+      await reputation.balanceOfLocalAt(signers[1].address, tx.blockNumber)
     ).to.equal(rep1);
     expect(
-      await reputation.balanceOfAt(signers[1].address, tx.blockNumber - 1)
+      await reputation.balanceOfLocalAt(signers[1].address, tx.blockNumber - 1)
     ).to.equal(0);
   });
 });

package/test/governance/StakersDistribution.test.ts

@@ -381,18 +381,22 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
     await simpleStaking.connect(staker).stake(stakingAmount, 0, false);
     await advanceBlocks(40);
     await increaseTime(86700 * 30); // Increase one month
-    const stakerGDAOBalanceBeforeStake = await grep.balanceOf(staker.address);
+    const stakerGDAOBalanceBeforeStake = await grep.balanceOfLocal(
+      staker.address
+    );
     await simpleStaking.connect(staker).stake(stakingAmount, 0, false);
-    const stakerGDAOBalanceAfterStake = await grep.balanceOf(staker.address);
+    const stakerGDAOBalanceAfterStake = await grep.balanceOfLocal(
+      staker.address
+    );
     await simpleStaking.connect(staker).withdrawRewards();
 
     const rewardsPerBlockAfterStake = await stakersDistribution.rewardsPerBlock(
       simpleStaking.address
     );
-    const GDAOBalanceBeforeWithdraw = await grep.balanceOf(staker.address);
+    const GDAOBalanceBeforeWithdraw = await grep.balanceOfLocal(staker.address);
     await advanceBlocks(10);
     await simpleStaking.connect(staker).withdrawStake(stakingAmount, false);
-    const GDAOBalanceAfterWithdraw = await grep.balanceOf(staker.address);
+    const GDAOBalanceAfterWithdraw = await grep.balanceOfLocal(staker.address);
     expect(rewardsPerBlockAfterStake).to.be.equal(rewardsPerBlockBeforeStake); // Should not update rewards per block since simplestaking blockend passed
     expect(GDAOBalanceBeforeWithdraw).to.be.equal(GDAOBalanceAfterWithdraw); // Should not earn any GDAO since simplestaking blockend passed
     expect(stakerGDAOBalanceAfterStake.gt(stakerGDAOBalanceBeforeStake)).to.be
@@ -432,10 +436,10 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
     const blockNumberOfStake = (await ethers.provider.getBlockNumber()) + 1;
     await simpleStaking.connect(staker).stake(stakingAmount, 0, false);
     await advanceBlocks(30);
-    const GDAOBalanceBeforeWithdraw = await grep.balanceOf(staker.address);
+    const GDAOBalanceBeforeWithdraw = await grep.balanceOfLocal(staker.address);
     await simpleStaking.connect(staker).withdrawStake(stakingAmount, false);
 
-    const GDAOBalanceAfterWithdraw = await grep.balanceOf(staker.address);
+    const GDAOBalanceAfterWithdraw = await grep.balanceOfLocal(staker.address);
     expect(GDAOBalanceAfterWithdraw).to.be.gt(GDAOBalanceBeforeWithdraw);
 
     expect(GDAOBalanceAfterWithdraw).to.be.equal(
@@ -750,12 +754,12 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
     const daiStakingRewardsPerBlock = await stakersDistribution.rewardsPerBlock(
       simpleStaking.address
     );
-    const gdaoBalanceBeforeWithdraw = await grep.balanceOf(staker.address);
+    const gdaoBalanceBeforeWithdraw = await grep.balanceOfLocal(staker.address);
     await simpleUsdcStaking
       .connect(staker)
       .withdrawStake(stakingAmountUsdc, false);
     await simpleStaking.connect(staker).withdrawStake(stakingAmountDai, false);
-    const gdaoBalanceAfterWithdraw = await grep.balanceOf(staker.address);
+    const gdaoBalanceAfterWithdraw = await grep.balanceOfLocal(staker.address);
     expect(gdaoBalanceAfterWithdraw.sub(gdaoBalanceBeforeWithdraw)).to.be.equal(
       UserPendingGdaos.add(usdcStakingRewardsPerBlock).add(
         daiStakingRewardsPerBlock.mul(2)