@gooddollar/goodprotocol 1.0.30-beta.2 → 1.0.30-beta.3

package/test/staking/StakingRewards.test.ts

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Contract } from "ethers";
 import { expect } from "chai";
 import { GoodMarketMaker } from "../../types";
@@ -51,19 +52,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
   before(async () => {
     [founder, staker, ...signers] = await ethers.getSigners();
     schemeMock = signers.pop();
-    const cdaiFactory = await ethers.getContractFactory("cDAIMock");
-    const cBatFactory = await ethers.getContractFactory("cBATMock");
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
-    goodCompoundStakingFactory = await getStakingFactory(
-      "GoodCompoundStakingV2"
-    );
-    goodCompoundStakingTestFactory = await getStakingFactory(
-      "GoodCompoundStakingTest"
-    );
 
-    const daiFactory = await ethers.getContractFactory("DAIMock");
     let {
       controller: ctrl,
       avatar: av,
@@ -79,7 +68,21 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       setReserveToken,
       genericCall: gc,
       COMP
-    } = await createDAO();
+    } = await loadFixture(createDAO);
+
+    const cdaiFactory = await ethers.getContractFactory("cDAIMock");
+    const cBatFactory = await ethers.getContractFactory("cBATMock");
+    const goodFundManagerFactory = await ethers.getContractFactory(
+      "GoodFundManager"
+    );
+    goodCompoundStakingFactory = await getStakingFactory(
+      "GoodCompoundStakingV2"
+    );
+    goodCompoundStakingTestFactory = await getStakingFactory(
+      "GoodCompoundStakingTest"
+    );
+
+    const daiFactory = await ethers.getContractFactory("DAIMock");
 
     genericCall = gc;
     dai = await ethers.getContractAt("DAIMock", daiAddress);
@@ -129,7 +132,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const tokenUsdOracleFactory = await ethers.getContractFactory(
       "BatUSDMockOracle"
     );
-    setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
+    await setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
 
     daiUsdOracle = await tokenUsdOracleFactory.deploy();
     const compUsdOracleFactory = await ethers.getContractFactory(
@@ -194,8 +197,8 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       JSON.stringify(IUniswapV2Pair.abi),
       staker
     ).connect(founder);
-    setDAOAddress("CDAI", cDAI.address);
-    setDAOAddress("DAI", dai.address);
+    await setDAOAddress("CDAI", cDAI.address);
+    await setDAOAddress("DAI", dai.address);
 
     batUsdOracle = await tokenUsdOracleFactory.deploy();
 
@@ -641,12 +644,13 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
 
     await advanceBlocks(4);
 
-    const userMintedAndPending = await goodCompoundStaking.getUserMintedAndPending(staker.address);
+    const userMintedAndPending =
+      await goodCompoundStaking.getUserMintedAndPending(staker.address);
     const userMintedReward = userMintedAndPending[0].toString();
     const userPendingReward = userMintedAndPending[1].toString();
     expect(userMintedReward).to.equal("5000");
     expect(userPendingReward).to.equal("2000");
-  
+
     await goodCompoundStaking
       .connect(staker)
       .withdrawStake(stakingAmount, false);
@@ -1430,7 +1434,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     expect(data.isBlackListed).to.equal(true);
   });
 
-  it("it should remove staking contract from active staking contracts when it's reward set to zero", async () => {
+  it("it should not remove staking contract from active staking contracts when it's reward set to zero", async () => {
     const simpleStaking1 = await goodCompoundStakingTestFactory.deploy(
       bat.address,
       cBat.address,
@@ -1449,9 +1453,6 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
     const activeContractsCount =
       await goodFundManager.getActiveContractsCount();
-    const lastActiveContractBeforeAdd = await goodFundManager.activeContracts(
-      activeContractsCount.sub(1)
-    );
 
     const simpleStaking = await goodCompoundStakingTestFactory.deploy(
       bat.address,
@@ -1471,9 +1472,9 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
     const activeContractsCountAfterAdded =
       await goodFundManager.getActiveContractsCount();
-    const lastActiveContractAfterAdd = await goodFundManager.activeContracts(
-      activeContractsCountAfterAdded.sub(1)
-    );
+
+    expect(activeContractsCountAfterAdded).equal(activeContractsCount.add(1));
+
     encodedData = goodFundManager.interface.encodeFunctionData(
       "setStakingReward",
       ["0", simpleStaking.address, 10, 1000, false] // set 10 gd per block
@@ -1485,16 +1486,15 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const lastActiveContractAfterRemove = await goodFundManager.activeContracts(
       activeContractsCountAfterRemoved.sub(1)
     );
-    expect(lastActiveContractBeforeAdd).to.be.equal(
-      lastActiveContractAfterRemove
-    );
-    expect(lastActiveContractAfterAdd).to.be.equal(simpleStaking.address);
-    expect(activeContractsCountAfterAdded).to.be.gt(activeContractsCount);
-    expect(activeContractsCountAfterAdded).to.be.gt(
+
+    expect(lastActiveContractAfterRemove).to.be.equal(simpleStaking.address);
+    expect(activeContractsCountAfterAdded).to.be.eq(
       activeContractsCountAfterRemoved
     );
-    expect(activeContractsCount).to.be.equal(activeContractsCountAfterRemoved);
+
+    expect(activeContractsCount).to.be.lt(activeContractsCountAfterRemoved);
   });
+
   it("it should distribute rewards correctly when there is multiple stakers", async () => {
     const simpleStaking1 = await goodCompoundStakingTestFactory.deploy(
       bat.address,

package/test/staking/StakingRewardsFixedAPY.test.ts

@@ -1,5 +1,6 @@
 import { expect } from "chai";
 import { ethers, waffle } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { createDAO, advanceBlocks } from "../helpers";
 import { StakingMockFixedAPY } from "../../types";
 import { default as StakingABI } from "../../artifacts/contracts/mocks/StakingMockFixedAPY.sol/StakingMockFixedAPY.json";
@@ -61,7 +62,7 @@ describe("StakingRewardsFixedAPY - generic staking for fixed APY rewards contrac
       gd,
       nameService: ns,
       setDAOAddress
-    } = await createDAO();
+    } = await loadFixture(createDAO);
 
     setNSAddress = setDAOAddress;
     nameService = ns;

package/test/staking/SwapHelper.test.ts

@@ -1,4 +1,5 @@
 import { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Contract } from "ethers";
 import { expect } from "chai";
 
@@ -38,6 +39,24 @@ describe("SwapHelper - Helper library for swap on the Uniswap", () => {
   before(async () => {
     [founder, staker, ...signers] = await ethers.getSigners();
     schemeMock = signers.pop();
+
+    let {
+      controller: ctrl,
+      avatar: av,
+      gd,
+      identity,
+      nameService: ns,
+      setDAOAddress: sda,
+      setSchemes,
+      marketMaker: mm,
+      daiAddress,
+      cdaiAddress,
+      reserve,
+      setReserveToken,
+      genericCall: gc,
+      COMP
+    } = await loadFixture(createDAO);
+
     const cdaiFactory = await ethers.getContractFactory("cDAIMock");
     const cBatFactory = await ethers.getContractFactory("cDecimalsMock");
     const goodFundManagerFactory = await ethers.getContractFactory(
@@ -54,22 +73,6 @@ describe("SwapHelper - Helper library for swap on the Uniswap", () => {
     );
     swapHelperTest = await swapHelperTestFactory.deploy();
     const daiFactory = await ethers.getContractFactory("DAIMock");
-    let {
-      controller: ctrl,
-      avatar: av,
-      gd,
-      identity,
-      nameService: ns,
-      setDAOAddress: sda,
-      setSchemes,
-      marketMaker: mm,
-      daiAddress,
-      cdaiAddress,
-      reserve,
-      setReserveToken,
-      genericCall: gc,
-      COMP
-    } = await createDAO();
 
     genericCall = gc;
     dai = await ethers.getContractAt("DAIMock", daiAddress);
@@ -109,7 +112,7 @@ describe("SwapHelper - Helper library for swap on the Uniswap", () => {
     const tokenUsdOracleFactory = await ethers.getContractFactory(
       "BatUSDMockOracle"
     );
-    setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
+    await setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
 
     const compUsdOracleFactory = await ethers.getContractFactory(
       "CompUSDMockOracle"

package/test/staking/UsdcAaveStaking.test.ts

@@ -1,4 +1,5 @@
 import { default as hre, ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BigNumber, Contract } from "ethers";
 import { expect } from "chai";
 import { GoodMarketMaker } from "../../types";
@@ -37,17 +38,6 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
     [founder, staker, ...signers] = await ethers.getSigners();
     schemeMock = signers.pop();
 
-    const cUsdcFactory = await ethers.getContractFactory("cUSDCMock");
-    const goodFundManagerFactory = await ethers.getContractFactory(
-      "GoodFundManager"
-    );
-    goodAaveStakingFactory = await getStakingFactory("GoodAaveStakingV2");
-
-    const lendingPoolFactory = await ethers.getContractFactory(
-      "LendingPoolMock"
-    );
-
-    const usdcFactory = await ethers.getContractFactory("USDCMock");
     let {
       controller: ctrl,
       avatar: av,
@@ -60,7 +50,20 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
       genericCall: gc,
       COMP,
       runAsAvatarOnly: raao
-    } = await createDAO();
+    } = await loadFixture(createDAO);
+
+    const cUsdcFactory = await ethers.getContractFactory("cUSDCMock");
+    const goodFundManagerFactory = await ethers.getContractFactory(
+      "GoodFundManager"
+    );
+    goodAaveStakingFactory = await getStakingFactory("GoodAaveStakingV2");
+
+    const lendingPoolFactory = await ethers.getContractFactory(
+      "LendingPoolMock"
+    );
+
+    const usdcFactory = await ethers.getContractFactory("USDCMock");
+
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     avatar = av;
     controller = ctrl;
@@ -96,7 +99,7 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
     const uniswap = await deployUniswap(comp, dai);
     uniswapRouter = uniswap.router;
     const { factory, weth } = uniswap;
-    setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
+    await setDAOAddress("UNISWAP_ROUTER", uniswapRouter.address);
     await factory.createPair(usdc.address, dai.address); // Create tokenA and dai pair
     const pairAddress = factory.getPair(usdc.address, dai.address);
     pair = new Contract(
@@ -139,23 +142,21 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
     ).deploy();
     await setDAOAddress("AAVE", aave.address);
     deployStaking = async () => {
-      return await goodAaveStakingFactory
-        .deploy()
-        .then(async contract => {
-          await contract.init(
-            usdc.address,
-            lendingPool.address,
-            nameService.address,
-            "Good USDC",
-            "gUSDC",
-            "172800",
-            daiUsdOracle.address,
-            incentiveController.address,
-            aaveUsdOracle.address,
-            [usdc.address, dai.address]
-          );
-          return contract;
-        });
+      return await goodAaveStakingFactory.deploy().then(async contract => {
+        await contract.init(
+          usdc.address,
+          lendingPool.address,
+          nameService.address,
+          "Good USDC",
+          "gUSDC",
+          "172800",
+          daiUsdOracle.address,
+          incentiveController.address,
+          aaveUsdOracle.address,
+          [usdc.address, dai.address]
+        );
+        return contract;
+      });
     };
     goodAaveStaking = await deployStaking();
     await usdc["mint(address,uint256)"](
@@ -318,15 +319,17 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
   it("should set gas cost to interest collection parameters", async () => {
     const stakingContract = await deployStaking();
     const collectGasCostBefore = await stakingContract.collectInterestGasCost();
-    const claimStakeGasCostBefore = await stakingContract.collectInterestGasCost();
+    const claimStakeGasCostBefore =
+      await stakingContract.collectInterestGasCost();
     await runAsAvatarOnly(
       stakingContract,
       "setcollectInterestGasCostParams(uint32,uint32)",
       999,
       999
-    )
+    );
     const collectGasCostAfter = await stakingContract.collectInterestGasCost();
-    const claimStakeGasCostAfter = await stakingContract.collectInterestGasCost();
+    const claimStakeGasCostAfter =
+      await stakingContract.collectInterestGasCost();
     expect(collectGasCostAfter).to.not.equal(collectGasCostBefore);
     expect(collectGasCostAfter).to.equal(999);
     expect(claimStakeGasCostAfter).to.not.equal(claimStakeGasCostBefore);

package/test/token/GoodDollar.test.ts

@@ -0,0 +1,342 @@
+import hre, { ethers, upgrades } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { expect } from "chai";
+import FeeFormulaABI from "@gooddollar/goodcontracts/build/contracts/SenderFeeFormula.json";
+import TransferAndCallMockABI from "@gooddollar/goodcontracts/build/contracts/TransferAndCallMock.json";
+import { IIdentity, GoodDollar, ISuperGoodDollar } from "../../types";
+import { createDAO, deploySuperGoodDollar } from "../helpers";
+import { Contract } from "ethers";
+
+const BN = ethers.BigNumber;
+
+describe("GoodDollar Token", () => {
+  let receiver: Contract,
+    identity,
+    feeFormula,
+    newFormula,
+    token: ISuperGoodDollar,
+    unCappedToken: ISuperGoodDollar,
+    cappedToken: ISuperGoodDollar,
+    newtoken: ISuperGoodDollar,
+    founder,
+    outsider,
+    whitelisted;
+  let signers;
+
+  let avatar, gd: ISuperGoodDollar, Controller, id: IIdentity, superFluid;
+
+  const regularTokenState = async () => {
+    const deployedDAO = createDAO("regular");
+    const token = (await ethers.getContractAt(
+      "GoodDollar",
+      (
+        await deployedDAO
+      ).gd
+    )) as GoodDollar;
+
+    await token.mint(founder.address, 100000000);
+
+    return token;
+  };
+
+  before(async () => {
+    [founder, whitelisted, outsider, ...signers] = await ethers.getSigners();
+
+    let {
+      daoCreator,
+      controller,
+      avatar: av,
+      gd: gooddollar,
+      identity: idv2,
+      sfContracts
+    } = await loadFixture(createDAO);
+
+    superFluid = sfContracts;
+    avatar = av;
+    identity = await ethers.getContractAt("IdentityV2", idv2);
+
+    const FeeFormulaFactory = new ethers.ContractFactory(
+      FeeFormulaABI.abi,
+      FeeFormulaABI.bytecode,
+      founder
+    );
+
+    receiver = await new ethers.ContractFactory(
+      TransferAndCallMockABI.abi,
+      TransferAndCallMockABI.bytecode,
+      founder
+    ).deploy();
+
+    token = (await ethers.getContractAt(
+      "ISuperGoodDollar",
+      gooddollar
+    )) as ISuperGoodDollar;
+    feeFormula = FeeFormulaFactory.attach(await token.formula());
+
+    // isProduction ? "GoodDollar" : "GoodDollar Dev",
+    //   "G$",
+    //   0,
+    //   FeeFormula.address,
+    //   Identity.address,
+    //   ethers.constants.AddressZero,
+    //   daoCreator.address
+    // unCappedToken = (await upgrades.deployProxy(
+    //   await ethers.getContractFactory("GoodDollar"),
+    //   [
+    //     "Test",
+    //     "TDD",
+    //     0,
+    //     feeFormula.address,
+    //     identity.address,
+    //     receiver.address,
+    //     founder.address
+    //   ],
+    //   {
+    //     initializer:
+    //       "initialize(string,string,uint256,address,address,address,address)"
+    //   }
+    // )) as GoodDollar;
+
+    unCappedToken = (await deploySuperGoodDollar(superFluid, [
+      "Test",
+      "TDD",
+      0,
+      feeFormula.address,
+      identity.address,
+      receiver.address,
+      founder.address
+    ])) as ISuperGoodDollar;
+
+    cappedToken = (await deploySuperGoodDollar(superFluid, [
+      "Test",
+      "TDD",
+      1000,
+      feeFormula.address,
+      identity.address,
+      receiver.address,
+      founder.address
+    ])) as ISuperGoodDollar;
+
+    newFormula = await FeeFormulaFactory.deploy(1);
+
+    newtoken = (await deploySuperGoodDollar(superFluid, [
+      "gd",
+      "gd",
+      1000000,
+      newFormula.address,
+      identity.address,
+      av,
+      founder.address
+    ])) as ISuperGoodDollar;
+
+    // cappedToken = (await upgrades.deployProxy(
+    //   await ethers.getContractFactory("GoodDollar"),
+    //   [
+    //     "Test",
+    //     "TDD",
+    //     1000,
+    //     feeFormula.address,
+    //     identity.address,
+    //     receiver.address,
+    //     founder.address
+    //   ],
+    //   {
+    //     initializer:
+    //       "initialize(string,string,uint256,address,address,address,address)"
+    //   }
+    // )) as GoodDollar;
+
+    // newtoken = (await upgrades.deployProxy(
+    //   await ethers.getContractFactory("GoodDollar"),
+    //   [
+    //     "gd",
+    //     "gd",
+    //     1000000,
+    //     newFormula.address,
+    //     identity.address,
+    //     av,
+    //     founder.address
+    //   ],
+    //   {
+    //     initializer:
+    //       "initialize(string,string,uint256,address,address,address,address)"
+    //   }
+    // )) as GoodDollar;
+
+    await token.mint(founder.address, 100000000);
+
+    await newtoken.mint(whitelisted.address, 30000);
+    await token.transfer(whitelisted.address, 30000);
+    await token.transfer(founder.address, 10000);
+    await token.transfer(outsider.address, 1000);
+    await identity.addWhitelisted(whitelisted.address);
+    await identity.addWhitelisted(outsider.address);
+  });
+
+  it("should have low gas cost for transfer with regular token", async () => {
+    const token = await loadFixture(regularTokenState);
+    const firstTime = await (
+      await token.transfer(signers[2].address, 1000)
+    ).wait();
+    const secondTime = await (
+      await token.transfer(signers[2].address, 1000)
+    ).wait();
+    expect(firstTime.gasUsed).lt(70000);
+    expect(secondTime.gasUsed).lt(55000);
+  });
+
+  it("should have high gas cost for transfer with superfluid token", async () => {
+    const firstTime = await (
+      await token.transfer(signers[2].address, 1000)
+    ).wait();
+    const secondTime = await (
+      await token.transfer(signers[2].address, 1000)
+    ).wait();
+    expect(firstTime.gasUsed).gt(160000);
+    expect(secondTime.gasUsed).gt(149000);
+  });
+
+  it("should have avatar as default pauser", async () => {
+    expect(await token.isPauser(avatar)).true;
+  });
+
+  it("should let owner set identity and formula", async () => {
+    await expect(newtoken.setFormula(ethers.constants.AddressZero)).not
+      .reverted;
+    await expect(newtoken.setIdentity(ethers.constants.AddressZero)).not
+      .reverted;
+    expect(await newtoken.identity()).eq(ethers.constants.AddressZero);
+    expect(await newtoken.formula()).eq(ethers.constants.AddressZero);
+    await newtoken.setIdentity(identity.address);
+    await newtoken.setFormula(newFormula.address);
+  });
+
+  it("should not let non owner set identity and formula", async () => {
+    await expect(
+      newtoken.connect(signers[0]).setFormula(ethers.constants.AddressZero)
+    ).revertedWith("not owner");
+    await expect(
+      newtoken.connect(signers[0]).setIdentity(ethers.constants.AddressZero)
+    ).revertedWith("not owner");
+  });
+
+  it("should fail transfer", async () => {
+    let data = "0x0";
+
+    await expect(
+      token
+        .connect(outsider)
+        .transferAndCall(
+          receiver.address,
+          (await token.balanceOf(outsider.address)).add(100000),
+          data
+        )
+    ).reverted;
+  });
+
+  it("should not transfer and not call function", async () => {
+    let data = "0x";
+
+    await expect(
+      token.transferAndCall(receiver.address, 1000, data)
+    ).revertedWith("Contract Fallback failed");
+    expect(await receiver.wasCalled()).false;
+  });
+
+  it("should transfer, not call and return true if not contract", async () => {
+    let data = "0x";
+
+    await expect(token.transferAndCall(founder.address, 300, data)).not
+      .reverted;
+  });
+
+  it("should transfer and call correct function on receiver contract", async () => {
+    let data = receiver.interface.encodeFunctionData("mockTransfer", []);
+
+    expect(await token.transferAndCall(receiver.address, 1000, data));
+    expect(await receiver.wasCalled()).true;
+  });
+
+  it("should increase allowance", async () => {
+    expect(await token.increaseAllowance(whitelisted.address, 2000));
+  });
+
+  it("should allow to transfer from", async () => {
+    await expect(
+      token
+        .connect(whitelisted)
+        .transferFrom(founder.address, whitelisted.address, 1000)
+    ).not.reverted;
+  });
+
+  it("should decrease allowance", async () => {
+    await expect(token.decreaseAllowance(whitelisted.address, 1000)).not
+      .reverted;
+  });
+
+  it("should allow to burn", async () => {
+    expect(token.connect(whitelisted)["burn(uint256)"](1000)).not.reverted;
+  });
+
+  it("should allow to burn from", async () => {
+    await expect(token.approve(whitelisted.address, 2000)).not.reverted;
+    await expect(token.connect(whitelisted).burnFrom(founder.address, 2000)).not
+      .reverted;
+  });
+
+  it("should not allow to mint beyond cap", async () => {
+    await expect(unCappedToken.mint(founder.address, 1000)).not.reverted;
+
+    await expect(cappedToken.mint(founder.address, 1200)).revertedWith(
+      "Cannot increase supply beyond cap"
+    );
+  });
+
+  it("should collect transaction fee", async () => {
+    const oldReserve = await token.balanceOf(avatar);
+
+    await token.connect(whitelisted).transfer(founder.address, 20000);
+
+    // Check that reserve has received fees
+    const reserve = (await token.balanceOf(avatar)) as any;
+
+    const reserveDiff = reserve.sub(oldReserve);
+    const totalFees = await token["getFees(uint256)"](20000).then(_ => _["0"]);
+    expect(reserveDiff.toString()).to.be.equal(totalFees.toString());
+  });
+
+  it("should get same results from overloaded getFees method", async () => {
+    const totalFees = await newtoken["getFees(uint256)"](3000) //fix overload issue
+      .then(_ => _["0"]);
+    const totalFees2 = await newtoken["getFees(uint256,address,address)"](
+      3000,
+      whitelisted.address,
+      whitelisted.address
+    ).then(_ => _["0"]);
+    expect(totalFees2.toNumber()).to.be.gt(0);
+    expect(totalFees2.toString()).to.be.equal(totalFees.toString());
+  });
+
+  it("should collect transaction fee from sender", async () => {
+    const oldReserve = await newtoken.balanceOf(avatar);
+    const oldFounder = await newtoken.balanceOf(founder.address);
+    const newWhitelistedBefore = await newtoken.balanceOf(whitelisted.address);
+
+    await newtoken.connect(whitelisted).transfer(founder.address, 20000);
+
+    // Check that reserve has received fees
+    const reserve = (await newtoken.balanceOf(avatar)) as any;
+    const newFounder = (await newtoken.balanceOf(founder.address)) as any;
+    const newWhitelisted = await newtoken.balanceOf(whitelisted.address);
+
+    const reserveDiff = reserve.sub(oldReserve);
+    const founderDiff = newFounder.sub(oldFounder);
+
+    const totalFees = await newtoken["getFees(uint256)"](20000).then(
+      _ => _["0"]
+    );
+    expect(reserveDiff.toString()).to.be.equal(totalFees.toString());
+    expect(founderDiff.toString()).to.be.equal("20000");
+    expect(newWhitelistedBefore.sub(newWhitelisted)).to.be.equal("20200"); //20000 + 1%
+  });
+});