@gooddollar/goodprotocol/test/governance/StakersDistribution.test.ts

GoodDollar Protocol

import { default as hre, ethers, upgrades } from "hardhat";
import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
import { BigNumber, Contract, Signer } from "ethers";
import { expect } from "chai";
import {
  GoodMarketMaker,
  CERC20,
  GoodReserveCDai,
  SimpleStaking,
  GReputation
} from "../../types";
import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
import {
  createDAO,
  increaseTime,
  advanceBlocks,
  deployUniswap
} from "../helpers";
import ContributionCalculation from "@gooddollar/goodcontracts/stakingModel/build/contracts/ContributionCalculation.json";
import { getStakingFactory } from "../helpers";

const BN = ethers.BigNumber;
export const NULL_ADDRESS = ethers.constants.AddressZero;
export const BLOCK_INTERVAL = 30;

describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () => {
  let dai: Contract;
  let cDAI: Contract;
  let goodReserve: GoodReserveCDai;
  let stakersDistribution: Contract;
  let goodFundManager: Contract;
  let simpleStaking: Contract;
  let simpleUsdcStaking: Contract;
  let usdcUsdOracle: Contract;
  let usdc: Contract;
  let cUsdc: Contract;
  let comp: Contract;
  let grep: GReputation;
  let avatar,
    goodDollar,
    identity,
    marketMaker: GoodMarketMaker,
    contribution,
    controller,
    founder,
    staker,
    sender,
    receiver,
    schemeMock,
    signers,
    nameService,
    initializeToken,
    genericCall,
    setDAOAddress,
    daiEthOracle,
    ethUsdOracle,
    gasFeeOracle,
    daiUsdOracle,
    compUsdOracle: Contract,
    deployDaiStaking;

  before(async () => {
    [founder, staker, sender, receiver, ...signers] = await ethers.getSigners();
    schemeMock = signers.pop();
    const cdaiFactory = await ethers.getContractFactory("cDAIMock");
    const cUsdcFactory = await ethers.getContractFactory("cUSDCMock");
    const usdcFactory = await ethers.getContractFactory("USDCMock");
    const goodFundManagerFactory = await ethers.getContractFactory(
      "GoodFundManager"
    );
    const stakersDistributiongFactory = await ethers.getContractFactory(
      "StakersDistribution"
    );

    let {
      controller: ctrl,
      avatar: av,
      gd,
      identity,
      daoCreator,
      nameService: ns,
      setDAOAddress: sda,
      setSchemes,
      marketMaker: mm,
      daiAddress,
      cdaiAddress,
      reserve,
      reputation,
      setReserveToken,
      genericCall: gc,
      COMP
    } = await loadFixture(createDAO);

    genericCall = gc;
    dai = await ethers.getContractAt("DAIMock", daiAddress);
    cDAI = await ethers.getContractAt("cDAIMock", cdaiAddress);
    avatar = av;
    controller = ctrl;
    setDAOAddress = sda;
    nameService = ns;
    initializeToken = setReserveToken;
    goodReserve = reserve as GoodReserveCDai;
    console.log("deployed dao", {
      founder: founder.address,
      gd,
      identity,
      controller,
      avatar
    });
    goodFundManager = await upgrades.deployProxy(
      goodFundManagerFactory,
      [nameService.address],
      { kind: "uups" }
    );
    grep = (await ethers.getContractAt(
      "GReputation",
      reputation
    )) as GReputation;
    console.log("Deployed goodfund manager", {
      manager: goodFundManager.address
    });
    goodDollar = await ethers.getContractAt("IGoodDollar", gd);
    contribution = await ethers.getContractAt(
      ContributionCalculation.abi,
      await nameService.getAddress("CONTRIBUTION_CALCULATION")
    );

    marketMaker = mm;

    console.log("deployed contribution, deploying reserve...", {
      founder: founder.address
    });

    console.log("setting permissions...");
    await setDAOAddress("MARKET_MAKER", marketMaker.address);
    await setDAOAddress("FUND_MANAGER", goodFundManager.address);
    const tokenUsdOracleFactory = await ethers.getContractFactory(
      "BatUSDMockOracle"
    );
    compUsdOracle = await (
      await ethers.getContractFactory("CompUSDMockOracle")
    ).deploy();

    daiUsdOracle = await tokenUsdOracleFactory.deploy();
    usdc = await usdcFactory.deploy();
    cUsdc = await cUsdcFactory.deploy(usdc.address);
    usdcUsdOracle = await tokenUsdOracleFactory.deploy();
    comp = COMP;
    await setDAOAddress("COMP", comp.address);
    const uniswap = await deployUniswap(comp, dai);
    const router = uniswap.router;
    await setDAOAddress("UNISWAP_ROUTER", router.address);

    let simpleStakingFactory = await getStakingFactory("GoodCompoundStakingV2");

    simpleUsdcStaking = await simpleStakingFactory
      .deploy()
      .then(async contract => {
        await contract.init(
          usdc.address,
          cUsdc.address,
          nameService.address,
          "Good USDC",
          "gUSDC",
          "172800",
          usdcUsdOracle.address,
          compUsdOracle.address,
          [usdc.address, daiAddress]
        );
        return contract;
      });

    deployDaiStaking = async () => {
      return simpleStakingFactory.deploy().then(async contract => {
        await contract.init(
          dai.address,
          cDAI.address,
          nameService.address,
          "Good DAI",
          "gDAI",
          "200",
          daiUsdOracle.address,
          compUsdOracle.address,
          []
        );
        return contract;
      });
    };

    simpleStaking = await deployDaiStaking();

    const ictrl = await ethers.getContractAt(
      "Controller",
      controller,
      schemeMock
    );
    const currentBlockNumber = await ethers.provider.getBlockNumber();
    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleStaking.address,
        currentBlockNumber,
        currentBlockNumber + 1000,
        false
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
    stakersDistribution = await upgrades.deployProxy(
      stakersDistributiongFactory,
      [nameService.address],
      { kind: "uups" }
    );

    await setDAOAddress("GDAO_STAKERS", stakersDistribution.address);
  });

  it("it should have 2M monthly Reputation distribution", async () => {
    const monthlyReputationDistribution =
      await stakersDistribution.monthlyReputationDistribution();
    expect(monthlyReputationDistribution).to.be.equal(
      ethers.utils.parseEther("2000000")
    );
  });

  it("it should have 0 monthly rewards since staking amount was zero while initializing stakersDistribution", async () => {
    const rewardsPerBlock = await stakersDistribution.rewardsPerBlock(
      simpleStaking.address
    );
    expect(rewardsPerBlock).to.be.equal(0);
  });

  it("It should update monthly rewards according to staking amount of staking contract after one month passed from initialized", async () => {
    const stakingAmount = ethers.utils.parseEther("1000");
    const rewardsPerBlockBeforeStake =
      await stakersDistribution.rewardsPerBlock(simpleStaking.address);

    await dai["mint(address,uint256)"](staker.address, stakingAmount.mul(2));
    await dai
      .connect(staker)
      .approve(simpleStaking.address, stakingAmount.mul(2));
    await simpleStaking.connect(staker).stake(stakingAmount, 0, false);
    await increaseTime(86700 * 30);
    await simpleStaking.connect(staker).stake(stakingAmount, 0, false);
    const rewardsPerBlockAfterStake = await stakersDistribution.rewardsPerBlock(
      simpleStaking.address
    );
    await simpleStaking
      .connect(staker)
      .withdrawStake(stakingAmount.mul(2), false);
    const rewardsPerBlockAfterWithdraw =
      await stakersDistribution.rewardsPerBlock(simpleStaking.address);
    const chainBlockPerMonth =
      await stakersDistribution.getChainBlocksPerMonth();
    expect(rewardsPerBlockBeforeStake).to.be.equal(BN.from("0"));
    expect(rewardsPerBlockAfterStake).to.be.equal(
      ethers.utils.parseEther("2000000").div(chainBlockPerMonth)
    );
    expect(rewardsPerBlockAfterStake).to.be.equal(rewardsPerBlockAfterWithdraw);
  });

  it("it should not be set monthly reputation when not Avatar", async () => {
    const transaction = await stakersDistribution
      .setMonthlyReputationDistribution("1000000")
      .catch(e => e);
    expect(transaction.message).to.have.string(
      "only avatar can call this method"
    );
  });

  it("it should set monthly reputation when Avatar", async () => {
    let encoded = stakersDistribution.interface.encodeFunctionData(
      "setMonthlyReputationDistribution",
      [ethers.utils.parseEther("1000000")]
    );
    await genericCall(stakersDistribution.address, encoded);
    const monthlyReputationDistribution =
      await stakersDistribution.monthlyReputationDistribution();
    expect(monthlyReputationDistribution).to.be.equal(
      ethers.utils.parseEther("1000000")
    );
    encoded = stakersDistribution.interface.encodeFunctionData(
      "setMonthlyReputationDistribution",
      [ethers.utils.parseEther("2000000")]
    );
    await genericCall(stakersDistribution.address, encoded);
  });

  it("it should distribute monthly rewards according to staking amount of contracts so in this particular case simpleStaking contract should get %75 of the monthly rewards ", async () => {
    const goodFundManagerFactory = await ethers.getContractFactory(
      "GoodFundManager"
    );

    const simpleStaking1 = await deployDaiStaking();

    const ictrl = await ethers.getContractAt(
      "Controller",
      controller,
      schemeMock
    );
    const currentBlockNumber = await ethers.provider.getBlockNumber();
    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleStaking1.address,
        currentBlockNumber,
        currentBlockNumber + 1000,
        false
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
    const stakingAmount = ethers.utils.parseEther("1000");
    const rewardsPerBlockBeforeStakeContractOne =
      await stakersDistribution.rewardsPerBlock(simpleStaking.address);
    const rewardsPerBlockBeforeStakeContractTwo =
      await stakersDistribution.rewardsPerBlock(simpleStaking1.address);

    await dai["mint(address,uint256)"](staker.address, stakingAmount.mul(100));
    await dai
      .connect(staker)
      .approve(simpleStaking.address, stakingAmount.mul(75));
    await simpleStaking.connect(staker).stake(stakingAmount.mul(50), 0, false);
    await dai
      .connect(staker)
      .approve(simpleStaking1.address, stakingAmount.mul(25));
    await simpleStaking1.connect(staker).stake(stakingAmount.mul(25), 0, false);
    await increaseTime(86700 * 30); // Increase one month
    await simpleStaking.connect(staker).stake(stakingAmount.mul(25), 0, false);

    const rewardsPerBlockAfterStakeContractOne =
      await stakersDistribution.rewardsPerBlock(simpleStaking.address);
    const rewardsPerBlockAftereStakeContractTwo =
      await stakersDistribution.rewardsPerBlock(simpleStaking1.address);
    await simpleStaking
      .connect(staker)
      .withdrawStake(stakingAmount.mul(75), false);
    expect(rewardsPerBlockAfterStakeContractOne).to.be.equal(
      rewardsPerBlockAftereStakeContractTwo.mul(3).add(1)
    ); // added 1 cause of precision loss
    encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleStaking1.address,
        currentBlockNumber,
        currentBlockNumber + 1000,
        true
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
  });

  it("It should not update monthly rewards if staking contract's blockEnd Passed", async () => {
    const goodFundManagerFactory = await ethers.getContractFactory(
      "GoodFundManager"
    );

    const ictrl = await ethers.getContractAt(
      "Controller",
      controller,
      schemeMock
    );
    const currentBlockNumber = await ethers.provider.getBlockNumber();
    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleStaking.address,
        currentBlockNumber - 5,
        currentBlockNumber + 20,
        false
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
    const stakingAmount = ethers.utils.parseEther("1000");
    await dai["mint(address,uint256)"](staker.address, stakingAmount.mul(2));
    await dai
      .connect(staker)
      .approve(simpleStaking.address, stakingAmount.mul(2));
    const rewardsPerBlockBeforeStake =
      await stakersDistribution.rewardsPerBlock(simpleStaking.address);
    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);
    await simpleStaking.connect(staker).stake(stakingAmount, 0, false);
    const stakerGDAOBalanceAfterStake = await grep.balanceOf(staker.address);
    await simpleStaking.connect(staker).withdrawRewards();

    const rewardsPerBlockAfterStake = await stakersDistribution.rewardsPerBlock(
      simpleStaking.address
    );
    const GDAOBalanceBeforeWithdraw = await grep.balanceOf(staker.address);
    await advanceBlocks(10);
    await simpleStaking.connect(staker).withdrawStake(stakingAmount, false);
    const GDAOBalanceAfterWithdraw = await grep.balanceOf(staker.address);
    expect(rewardsPerBlockAfterStake).to.not.be.equal(
      rewardsPerBlockBeforeStake
    ); // Should update rewards per block every stake/withdraw
    expect(GDAOBalanceBeforeWithdraw).to.be.equal(GDAOBalanceAfterWithdraw); // Should not earn any GDAO since simplestaking blockend passed
    expect(stakerGDAOBalanceAfterStake.gt(stakerGDAOBalanceBeforeStake)).to.be
      .true;
  });

  it("it should give distribute if blockend passed but some of the rewards during reward period was not distributed", async () => {
    const goodFundManagerFactory = await ethers.getContractFactory(
      "GoodFundManager"
    );

    const ictrl = await ethers.getContractAt(
      "Controller",
      controller,
      schemeMock
    );
    const currentBlockNumber = await ethers.provider.getBlockNumber();
    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleStaking.address,
        currentBlockNumber - 5,
        currentBlockNumber + 20,
        false
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
    const stakingAmount = ethers.utils.parseEther("1000");
    await simpleStaking.connect(staker).withdrawStake(stakingAmount, false);

    await dai["mint(address,uint256)"](staker.address, stakingAmount);
    await dai.connect(staker).approve(simpleStaking.address, stakingAmount);
    const rewardsPerBlock = await stakersDistribution.rewardsPerBlock(
      simpleStaking.address
    );
    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);
    await simpleStaking.connect(staker).withdrawStake(stakingAmount, false);

    const GDAOBalanceAfterWithdraw = await grep.balanceOf(staker.address);
    expect(GDAOBalanceAfterWithdraw).to.be.gt(GDAOBalanceBeforeWithdraw);

    expect(GDAOBalanceAfterWithdraw).to.be.equal(
      GDAOBalanceBeforeWithdraw.add(
        rewardsPerBlock.mul(currentBlockNumber + 20 - blockNumberOfStake)
      )
    );
  });

  it("it should not increaseProductivity of staking contract which is blacklisted", async () => {
    const goodFundManagerFactory = await ethers.getContractFactory(
      "GoodFundManager"
    );

    const simpleStaking1 = await deployDaiStaking();

    const ictrl = await ethers.getContractAt(
      "Controller",
      controller,
      schemeMock
    );
    const currentBlockNumber = await ethers.provider.getBlockNumber();
    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleStaking1.address,
        currentBlockNumber - 5,
        currentBlockNumber + 20,
        true
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
    const stakingAmount = ethers.utils.parseEther("1000");
    await dai["mint(address,uint256)"](staker.address, stakingAmount);
    await dai.connect(staker).approve(simpleStaking1.address, stakingAmount);
    await simpleStaking1.connect(staker).stake(stakingAmount, 0, false);
    const productivityOfStaker = await stakersDistribution.getProductivity(
      simpleStaking1.address,
      staker.address
    );
    expect(productivityOfStaker[0]).to.be.equal(0);
  });

  it("it should not decreaseProductivity of staking contract which is blacklisted", async () => {
    const goodFundManagerFactory = await ethers.getContractFactory(
      "GoodFundManager"
    );

    const simpleStaking1 = await deployDaiStaking();

    const ictrl = await ethers.getContractAt(
      "Controller",
      controller,
      schemeMock
    );
    const currentBlockNumber = await ethers.provider.getBlockNumber();
    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "100000",
        simpleStaking1.address,
        currentBlockNumber - 5,
        currentBlockNumber + 20,
        false
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
    await increaseTime(86700 * 30); // Increase one month
    const stakingAmount = ethers.utils.parseEther("1000");
    await dai["mint(address,uint256)"](staker.address, stakingAmount);
    await dai.connect(staker).approve(simpleStaking1.address, stakingAmount);
    await simpleStaking1.connect(staker).stake(stakingAmount, 0, false);
    await advanceBlocks(5); //should accumulate some gdao rewards

    let pendingGDAO = await stakersDistribution.getUserPendingRewards(
      [simpleStaking1.address],
      staker.address
    );

    expect(pendingGDAO).gt(0);

    encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleStaking1.address,
        currentBlockNumber - 5,
        currentBlockNumber + 20,
        true
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
    await simpleStaking1.connect(staker).withdrawStake(stakingAmount, false);
    const productivityOfStaker = await stakersDistribution.getProductivity(
      simpleStaking1.address,
      staker.address
    );
    expect(productivityOfStaker[0]).to.be.equal(stakingAmount);

    const repBefore = await grep["balanceOf(address)"](staker.address);
    await stakersDistribution.claimReputation(staker.address, [
      simpleStaking1.address
    ]);
    const repAfter = await grep["balanceOf(address)"](staker.address);

    expect(repBefore).to.equal(repAfter); //should not have been awarded rep accumulated before blacklisting contract

    pendingGDAO = await stakersDistribution.getUserPendingRewards(
      [simpleStaking1.address],
      staker.address
    );
    expect(pendingGDAO).equal(0); //should have 0 pending after contract was blacklisted
  });

  it("it should not earn rewards when current block < startBlock", async () => {
    const goodFundManagerFactory = await ethers.getContractFactory(
      "GoodFundManager"
    );

    const simpleStaking1 = await deployDaiStaking();

    const ictrl = await ethers.getContractAt(
      "Controller",
      controller,
      schemeMock
    );
    const currentBlockNumber = await ethers.provider.getBlockNumber();
    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleStaking1.address,
        currentBlockNumber + 500,
        currentBlockNumber + 1000,
        false
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
    const stakingAmount = ethers.utils.parseEther("1000");
    const userProductivityBeforeStaking =
      await stakersDistribution.getProductivity(
        simpleStaking1.address,
        staker.address
      );
    await dai["mint(address,uint256)"](staker.address, stakingAmount);
    await dai.connect(staker).approve(simpleStaking1.address, stakingAmount);
    await simpleStaking1.connect(staker).stake(stakingAmount, 0, false);
    const userProductivityAfterStaking =
      await stakersDistribution.getProductivity(
        simpleStaking1.address,
        staker.address
      );
    await advanceBlocks(10);
    const userPendingRewards = await stakersDistribution.getUserPendingReward(
      simpleStaking1.address,
      currentBlockNumber + 500,
      currentBlockNumber + 1000,
      staker.address
    );

    expect(userProductivityAfterStaking[0]).to.be.equal(stakingAmount);
    expect(userProductivityAfterStaking[0]).to.be.gt(
      userProductivityBeforeStaking[0]
    );
    expect(userPendingRewards).to.be.equal(0);
    encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleStaking1.address,
        currentBlockNumber + 500,
        currentBlockNumber + 1000,
        true
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
  });

  it("Accumulated per share has enough precision when reward << totalproductivity", async () => {
    const goodFundManagerFactory = await ethers.getContractFactory(
      "GoodFundManager"
    );

    const simpleStaking1 = await deployDaiStaking();
    const ictrl = await ethers.getContractAt(
      "Controller",
      controller,
      schemeMock
    );
    const currentBlockNumber = await ethers.provider.getBlockNumber();
    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleStaking1.address,
        currentBlockNumber - 10,
        currentBlockNumber + 100,
        false
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
    const stakingAmount = ethers.utils.parseEther("10000000000");
    await dai["mint(address,uint256)"](staker.address, stakingAmount); // 10 billion dai to stake
    await dai.connect(staker).approve(simpleStaking1.address, stakingAmount);
    const stakeBlockNumber = (await ethers.provider.getBlockNumber()) + 1;
    await simpleStaking1.connect(staker).stake(stakingAmount, 0, false);
    const rewardsPerBlock = await stakersDistribution.rewardsPerBlock(
      simpleStaking1.address
    );
    await advanceBlocks(4);
    const gdaoBalanceBeforeWithdraw = await grep.balanceOf(staker.address);
    await simpleStaking1.connect(staker).withdrawStake(stakingAmount, false);
    const withdrawBlockNumber = await ethers.provider.getBlockNumber();
    await stakersDistribution.claimReputation(staker.address, [
      simpleUsdcStaking.address,
      simpleStaking.address
    ]);

    const gdaoBalanceAfterWithdraw = await grep.balanceOf(staker.address);
    const calculatedNewBalance = gdaoBalanceBeforeWithdraw.add(
      rewardsPerBlock.mul(withdrawBlockNumber - stakeBlockNumber)
    );
    expect(gdaoBalanceAfterWithdraw).to.be.gt(gdaoBalanceBeforeWithdraw);

    expect(gdaoBalanceAfterWithdraw).to.be.equal(calculatedNewBalance);

    encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleStaking1.address,
        currentBlockNumber + 500,
        currentBlockNumber + 1000,
        true
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
  });

  it("it should distribute rewards properly when staking contract's token is different decimals than 18", async () => {
    const goodFundManagerFactory = await ethers.getContractFactory(
      "GoodFundManager"
    );
    const ictrl = await ethers.getContractAt(
      "Controller",
      controller,
      schemeMock
    );
    const currentBlockNumber = await ethers.provider.getBlockNumber();
    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleStaking.address,
        currentBlockNumber - 5,
        currentBlockNumber + 200,
        false
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
    encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleUsdcStaking.address,
        currentBlockNumber - 5,
        currentBlockNumber + 200,
        false
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
    const stakingAmountDai = ethers.utils.parseEther("10000");
    const stakingAmountUsdc = ethers.utils.parseUnits("10000", 6);
    await dai["mint(address,uint256)"](staker.address, stakingAmountDai);
    await dai.connect(staker).approve(simpleStaking.address, stakingAmountDai);
    await usdc["mint(address,uint256)"](staker.address, stakingAmountUsdc);
    await usdc
      .connect(staker)
      .approve(simpleUsdcStaking.address, stakingAmountUsdc);
    await simpleStaking.connect(staker).stake(stakingAmountDai, 0, false);
    await increaseTime(86700 * 30); // Increase one month
    await simpleUsdcStaking.connect(staker).stake(stakingAmountUsdc, 0, false);
    const usdcStakingProductivity = await stakersDistribution.getProductivity(
      simpleUsdcStaking.address,
      staker.address
    );
    const daiStakingProductivity = await stakersDistribution.getProductivity(
      simpleStaking.address,
      staker.address
    );
    await advanceBlocks(10);
    const UserPendingGdaos = await stakersDistribution.getUserPendingRewards(
      [simpleStaking.address, simpleUsdcStaking.address],
      staker.address
    );
    expect(UserPendingGdaos).to.be.gt(0);
    const usdcStakingPendingGdaos =
      await stakersDistribution.getUserPendingReward(
        simpleUsdcStaking.address,
        currentBlockNumber - 5,
        currentBlockNumber + 200,
        staker.address
      );
    expect(usdcStakingPendingGdaos).to.be.gt(0);
    const daiStakingPendingGdaos =
      await stakersDistribution.getUserPendingReward(
        simpleStaking.address,
        currentBlockNumber - 5,
        currentBlockNumber + 200,
        staker.address
      );
    expect(daiStakingPendingGdaos).to.be.gt(0);
    const usdcStakingRewardsPerBlock =
      await stakersDistribution.rewardsPerBlock(simpleUsdcStaking.address);
    const daiStakingRewardsPerBlock = await stakersDistribution.rewardsPerBlock(
      simpleStaking.address
    );

    expect(usdcStakingRewardsPerBlock).to.equal(daiStakingRewardsPerBlock);

    await simpleUsdcStaking
      .connect(staker)
      .withdrawStake(stakingAmountUsdc, false);
    await simpleStaking.connect(staker).withdrawStake(stakingAmountDai, false);

    await stakersDistribution.claimReputation(staker.address, [
      simpleUsdcStaking.address,
      simpleStaking.address
    ]);

    expect(UserPendingGdaos).to.be.equal(
      usdcStakingPendingGdaos.add(daiStakingPendingGdaos)
    );
    expect(usdcStakingProductivity[0]).to.be.equal(stakingAmountUsdc.mul(1e12)); // mul with 1e12 since usdc in 6 decimals but we keep productivity in 18 decimals
    expect(daiStakingProductivity[0]).to.be.equal(stakingAmountDai);
    expect(usdcStakingProductivity[0]).to.be.equal(daiStakingProductivity[0]);
    expect(usdcStakingProductivity[1]).to.be.equal(daiStakingProductivity[1]);
    expect(usdcStakingRewardsPerBlock).to.be.equal(daiStakingRewardsPerBlock);
  });

  it("should be able to transfer staking token when using stakersdistribution", async () => {
    const stakingAmountDai = ethers.utils.parseEther("10000");
    const stakingAmountUsdc = ethers.utils.parseUnits("10000", 6);
    await dai["mint(address,uint256)"](staker.address, stakingAmountDai);
    await dai.connect(staker).approve(simpleStaking.address, stakingAmountDai);
    await usdc["mint(address,uint256)"](staker.address, stakingAmountUsdc);
    await usdc
      .connect(staker)
      .approve(simpleUsdcStaking.address, stakingAmountUsdc);
    await simpleStaking.connect(staker).stake(stakingAmountDai, 0, false);
    await increaseTime(86700 * 30); // Increase one month
    await simpleUsdcStaking.connect(staker).stake(stakingAmountUsdc, 0, false);
    await advanceBlocks(10);

    await simpleUsdcStaking
      .connect(staker)
      .transfer(signers[1].address, stakingAmountUsdc);

    expect(await simpleUsdcStaking.balanceOf(signers[1].address)).to.eq(
      stakingAmountUsdc
    );
    expect(await simpleUsdcStaking.balanceOf(staker.address)).to.eq(0);
    // await expect(
    //   simpleStaking
    //     .connect(staker)
    //     .transfer(signers[1].address, ethers.utils.parseEther("10000"))
    // ).to.not.reverted;
  });

  it("it should distribute rewards properly when transeferring a staking contract's token that's different decimals than 18 decimals", async () => {
    const goodFundManagerFactory = await ethers.getContractFactory(
      "GoodFundManager"
    );
    const ictrl = await ethers.getContractAt(
      "Controller",
      controller,
      schemeMock
    );
    const currentBlockNumber = await ethers.provider.getBlockNumber();
    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "1000",
        simpleUsdcStaking.address,
        currentBlockNumber - 5,
        currentBlockNumber + 200,
        false
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
    const stakingAmountUsdc = ethers.utils.parseUnits("10000", 6);
    await usdc["mint(address,uint256)"](sender.address, stakingAmountUsdc);
    await usdc
      .connect(sender)
      .approve(simpleUsdcStaking.address, stakingAmountUsdc);
    await increaseTime(86700 * 30); // Increase one month
    await simpleUsdcStaking.connect(sender).stake(stakingAmountUsdc, 0, false);
    await simpleUsdcStaking
      .connect(sender)
      .transfer(receiver.address, stakingAmountUsdc);
    await advanceBlocks(10);
    const UserPendingGdaos = await stakersDistribution.getUserPendingRewards(
      [simpleUsdcStaking.address],
      receiver.address
    );
    expect(UserPendingGdaos).to.be.gt(0);
    expect(UserPendingGdaos.toString().length).to.be.gt(18);
    const usdcStakingPendingGdaos =
      await stakersDistribution.getUserPendingReward(
        simpleUsdcStaking.address,
        currentBlockNumber - 5,
        currentBlockNumber + 200,
        receiver.address
      );
    expect(usdcStakingPendingGdaos).to.be.gt(0);
    expect(usdcStakingPendingGdaos.toString().length).to.be.gt(18);
  });

  it("should get user minted and pending rewards", async () => {
    const goodFundManagerFactory = await ethers.getContractFactory(
      "GoodFundManager"
    );

    const simpleStaking1 = await deployDaiStaking();
    const ictrl = await ethers.getContractAt(
      "Controller",
      controller,
      schemeMock
    );
    const currentBlockNumber = await ethers.provider.getBlockNumber();
    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "100000",
        simpleStaking1.address,
        currentBlockNumber - 5,
        currentBlockNumber + 20,
        false
      ] // set 10 gd per block
    );
    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);

    let [userMintedRewardBeforeStake, userPendingRewardBeforeStake] =
      await getUserMintedAndPendingRewards(
        staker.address,
        simpleStaking1.address
      );
    expect(userMintedRewardBeforeStake).to.eq("0");
    expect(userPendingRewardBeforeStake).to.eq("0");

    const stakingAmount = ethers.utils.parseEther("1000");
    await dai["mint(address,uint256)"](staker.address, stakingAmount);
    await dai.connect(staker).approve(simpleStaking1.address, stakingAmount);
    await simpleStaking1.connect(staker).stake(stakingAmount, 0, false);
    await advanceBlocks(5); //should accumulate some gdao rewards

    let [userMintedRewardAfterStake, userPendingRewardAfterStake] =
      await getUserMintedAndPendingRewards(
        staker.address,
        simpleStaking1.address
      );
    expect(userMintedRewardAfterStake).eq(0);
    expect(userPendingRewardAfterStake).gt(0);

    await stakersDistribution.claimReputation(staker.address, [
      simpleStaking1.address
    ]);

    let [userMintedRewardAfterClaim, userPendingRewardAfterClaim] =
      await getUserMintedAndPendingRewards(
        staker.address,
        simpleStaking1.address
      );
    expect(userMintedRewardAfterClaim).gt(0);
    expect(userPendingRewardAfterClaim).eq(0);
  });

  async function getUserMintedAndPendingRewards(
    stakerAddress,
    stakingContractAddress
  ) {
    const userMintedAndPending =
      await stakersDistribution.getUserMintedAndPending(
        [stakingContractAddress],
        stakerAddress
      );
    const userMintedReward = userMintedAndPending[0];
    const userPendingReward = userMintedAndPending[1];

    return [userMintedReward, userPendingReward];
  }

  it("should update user rewards when monthly rate has changed", async () => {
    const goodFundManagerFactory = await ethers.getContractFactory(
      "GoodFundManager"
    );

    const simpleStaking1 = await deployDaiStaking();
    const ictrl = await ethers.getContractAt(
      "Controller",
      controller,
      schemeMock
    );
    const currentBlockNumber = await ethers.provider.getBlockNumber();
    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
      "setStakingReward",
      [
        "100000",
        simpleStaking1.address,
        currentBlockNumber - 5,
        currentBlockNumber + 20,
        false
      ] // set 10 gd per block
    );

    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);

    let [userMintedRewardBeforeStake, userPendingRewardBeforeStake] =
      await getUserMintedAndPendingRewards(
        staker.address,
        simpleStaking1.address
      );
    expect(userMintedRewardBeforeStake).to.eq("0");
    expect(userPendingRewardBeforeStake).to.eq("0");

    const stakingAmount = ethers.utils.parseEther("1000");
    await dai["mint(address,uint256)"](staker.address, stakingAmount);
    await dai.connect(staker).approve(simpleStaking1.address, stakingAmount);
    await simpleStaking1.connect(staker).stake(stakingAmount, 0, false);
    await advanceBlocks(5); //should accumulate some gdao rewards

    const rewardsPerBlockBefore = await stakersDistribution.rewardsPerBlock(
      simpleStaking1.address
    );

    // reduce rewarsd speed by half from 2m to 1m
    let encoded = stakersDistribution.interface.encodeFunctionData(
      "setMonthlyReputationDistribution",
      [ethers.utils.parseEther("1000000")]
    );
    await genericCall(stakersDistribution.address, encoded);
    const rewardsPerBlockAfter = await stakersDistribution.rewardsPerBlock(
      simpleStaking1.address
    );
    let [userMintedRewardAfterStake, userPendingRewardAfterStake] =
      await getUserMintedAndPendingRewards(
        staker.address,
        simpleStaking1.address
      );
    expect(userMintedRewardAfterStake).eq(0);
    expect(userPendingRewardAfterStake).gt(0);

    await advanceBlocks(4); //should accumulate some gdao rewards
    let [userMintedRewardAfterUpdate, userPendingRewardAfterUpdate] =
      await getUserMintedAndPendingRewards(
        staker.address,
        simpleStaking1.address
      );
    expect(userMintedRewardAfterUpdate).eq(0);
    // rewards speed has been reduced by half,
    expect(rewardsPerBlockAfter).lt(rewardsPerBlockBefore.mul(55).div(100));
    // was forced 4 blocks to pass since reward update
    expect(userPendingRewardAfterUpdate).eq(
      userPendingRewardAfterStake.add(rewardsPerBlockAfter.mul(4))
    );
  });
});