@gooddollar/goodprotocol/test/staking/StakingRewardsFixedAPY.test.ts

GoodDollar Protocol

import { expect } from "chai";
import { ethers } 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";
const BN = ethers.BigNumber;

// APY=5% | Blocks per year = 12*60*24*365 = 6307200
// per block = nroot(1+0.05,numberOfBlocksPerYear) = 1000000007735630000
const BLOCKS_ONE_YEAR = 6307200;
const BLOCKS_FOUR_YEARS = 25228800;
const BLOCKS_TEN_YEARS = 63072000;
const INTEREST_RATE_5APY_X64 = BN.from("1000000007735630000"); // x64 representation of same number
const INTEREST_RATE_5APY_128 = BN.from("18446744216406738474"); // 128 representation of same number
// APY = 10% | nroot(1+0.10,numberOfBlocksPerYear) = 1000000015111330000
const INTEREST_RATE_10APY_X64 = BN.from("1000000015111330000"); // x64 representation of same number
const INTEREST_RATE_10APY_128 = BN.from("18446744352464388739"); // 128 representation of same number
// APY = 8% | nroot(1+0.08,numberOfBlocksPerYear) = 1000000012202093100
const INTEREST_RATE_8APY_X64 = BN.from("1000000012202093100"); // x64 representation of same number

describe("StakingRewardsFixedAPY - generic staking for fixed APY rewards contract", () => {
  let signers,
    setNSAddress,
    nameService,
    avatar,
    genericCall,
    controller,
    fixedStaking: StakingMockFixedAPY,
    goodDollar,
    founder,
    staker1,
    staker2,
    staker3,
    staker4;

  async function stake(_staker, _amount, contract = fixedStaking) {
    await contract.connect(_staker).stake(_staker.address, _amount);
  }

  // on withdraw: _amount / sharePrice = shares redeemed
  // on stake: _amount / sharePrice = shares added
  async function getExpectedSharesChange(_amount, _contract = fixedStaking) {
    return BN.from(_amount)
      .mul(await _contract.SHARE_PRECISION())
      .div(await _contract.sharePrice());
  }

  async function expectSavings(_staker, _amount, _contract = fixedStaking) {
    const savings = await _contract.getSavings(_staker.address);
    expect(savings.eq(_amount)).to.be.true;
  }

  before(async () => {
    [founder, staker1, staker2, staker3, staker4, ...signers] =
      await ethers.getSigners();

    let {
      controller: ctrl,
      avatar: av,
      genericCall: gc,
      gd,
      nameService: ns,
      setDAOAddress
    } = await loadFixture(createDAO);

    setNSAddress = setDAOAddress;
    nameService = ns;
    avatar = av;
    genericCall = gc;
    controller = ctrl;
    goodDollar = await ethers.getContractAt("IGoodDollar", gd);
  });

  const fixture_initOnly = async () => {
    const staking: StakingMockFixedAPY = (await ethers.deployContract(
      "StakingMockFixedAPY",
      [INTEREST_RATE_5APY_X64]
    )) as StakingMockFixedAPY;

    return { staking };
  };

  const fixture_2 = async () => {
    const staking: StakingMockFixedAPY = (await ethers.deployContract(
      "StakingMockFixedAPY",
      [INTEREST_RATE_5APY_X64]
    )) as StakingMockFixedAPY;

    return { staking };
  };

  const fixture_1year = async () => {
    const staking: StakingMockFixedAPY = (await ethers.deployContract(
      "StakingMockFixedAPY",
      [INTEREST_RATE_5APY_X64]
    )) as StakingMockFixedAPY;

    await stake(staker1, 10000, staking);
    await stake(staker2, 10000, staking);
    await stake(staker3, 10000, staking);

    await advanceBlocks(BLOCKS_ONE_YEAR);
    return { staking };
  };

  const fixture_1year_single = async () => {
    const staking: StakingMockFixedAPY = (await ethers.deployContract(
      "StakingMockFixedAPY",
      [INTEREST_RATE_5APY_X64]
    )) as StakingMockFixedAPY;

    await stake(staker3, 10000, staking);

    await advanceBlocks(BLOCKS_ONE_YEAR);
    return { staking };
  };

  it("should set APY successfully", async () => {
    const { staking } = await loadFixture(fixture_initOnly);

    const beforeSetInterestRateIn128 = await staking.interestRatePerBlockX64();

    const interestRatePerBlockX64 = BN.from(INTEREST_RATE_10APY_X64); // x64 representation of same number
    const interestRateInt128Format = BN.from(INTEREST_RATE_10APY_128); // 128 representation of same number
    await staking.setAPY(interestRatePerBlockX64);

    const afterSetInterestRateIn128 = await staking.interestRatePerBlockX64();

    expect(afterSetInterestRateIn128).to.not.equal(beforeSetInterestRateIn128);
    expect(afterSetInterestRateIn128).to.equal(interestRateInt128Format);
  });

  it("should update staker info after stake operation", async () => {
    const { staking } = await loadFixture(fixture_initOnly);

    await stake(staker1, 9000, staking);

    let info = await staking.stakersInfo(staker1.address);
    const initialShares = (await staking.SHARE_DECIMALS()).mul(9000);
    expect(info.lastSharePrice)
      .to.equal(
        (await staking.SHARE_PRECISION()).div(await staking.SHARE_DECIMALS())
      )
      .to.eq(await staking.sharePrice()); // (1g$ with 2 decimals)
    expect(await staking.sharesSupply())
      .to.equal(initialShares)
      .to.equal(await staking.totalSupply());
    expect(await staking.sharesOf(staker1.address))
      .eq(initialShares)
      .eq(await staking.balanceOf(staker1.address));
    expect(info.rewardsPaid).to.equal(0);
  });

  it("should handle stake/withdraw the minimal amount of 1", async () => {
    const { staking } = await loadFixture(fixture_initOnly);

    await stake(staker4, 1, staking);

    await advanceBlocks(BLOCKS_TEN_YEARS);
    await advanceBlocks(BLOCKS_FOUR_YEARS);

    await expectSavings(staker4, 1, staking); // (1.01^14) = 1.979931
    // await expect((await staking.sharePrice()).eq(BN.from(1979931))).to.be.true;

    await advanceBlocks(BLOCKS_ONE_YEAR);

    await expectSavings(staker4, 2, staking); // (1.01^15) = 2.078928
    await expect((await staking.sharePrice()).eq(207892821613185)).to.be.true;

    const minimalShares = await staking.amountToShares(1);
    const stakerInfo = await staking.stakersInfo(staker4.address);
    console.log({
      sharePrice: await staking.sharePrice(),
      minimalShares,
      stakerInfo,
      stakerShares: await staking.balanceOf(staker4.address)
    });
    await staking.withdraw(staker4.address, minimalShares); //this also withdraws the donated rewards

    let info = await staking.stakersInfo(staker4.address);
    await expectSavings(staker4, 1, staking);
    expect(info.rewardsPaid).to.equal(1);
    expect(await staking.balanceOf(staker4.address)).to.equal(
      10000 - minimalShares.toNumber()
    );

    await expect(
      staking.withdraw(
        staker4.address,
        (await staking.amountToShares(1)).sub(1)
      )
    ).revertedWith(/min shares/);
  });

  it("should fail on staking 0", async () => {
    const { staking } = await loadFixture(fixture_initOnly);
    await expect(stake(staker4, 0, staking)).to.be.revertedWith(/stake 0/);
  });

  xit("should fail on staking with donationRatio > 100", async () => {
    const { staking } = await loadFixture(fixture_initOnly);
    await expect(stake(staker4, 1, 101, staking)).to.be.revertedWith(
      /donation/
    );
  });

  xit("should fail on staking less than minimal amount of 1", async () => {
    const { staking } = await loadFixture(fixture_initOnly);
    await expect(stake(staker4, 1, staking)).to.be.reverted;
  });

  it("Should fail to withdraw exceeding amount", async () => {
    const { staking } = await loadFixture(fixture_initOnly);
    await stake(staker1, 1000, staking);

    const shares = await staking.balanceOf(staker1.address);
    await expect(staking.withdraw(staker1.address, shares.add(1))).revertedWith(
      /no balance/
    );
  });

  it("Should fail to withdraw when empty balance", async () => {
    const { staking } = await loadFixture(fixture_initOnly);

    await expect(staking.withdraw(staker1.address, 0)).revertedWith(
      /no balance/
    );
  });

  it("should update global stats after stake operation", async () => {
    const { staking } = await loadFixture(fixture_initOnly);
    const statsBefore = await staking.stats();
    const PRECISION = await staking.PRECISION();

    await stake(staker1, 9000, staking);

    const statsAfter = await staking.stats();
    expect(statsAfter.lastUpdateBlock.gt(statsBefore.lastUpdateBlock));
    expect(statsAfter.totalStaked).to.equal(9000);
    expect(await staking.sharesSupply()).eq(
      (await staking.SHARE_DECIMALS()).mul(9000)
    );
    expect(statsAfter.totalRewardsPaid).to.equal(0);
    expect(statsAfter.savings).to.equal(PRECISION.mul(9000));
  });

  it("should update staker info after withdraw operation", async () => {
    const { staking } = await loadFixture(fixture_initOnly);
    await stake(staker1, 9000, staking);
    await advanceBlocks(BLOCKS_ONE_YEAR);

    const sharesToWithdraw = await staking.amountToShares(4000);
    const rewardsBalanceBefore = await staking.earned(staker1.address);
    expect(rewardsBalanceBefore).eq(450);
    await staking.withdraw(staker1.address, sharesToWithdraw);

    let info = await staking.stakersInfo(staker1.address);

    const initialShares = (await staking.SHARE_DECIMALS()).mul(9000);
    const shares = await staking.sharesOf(staker1.address);
    const savings = await staking.getSavings(staker1.address);
    const rewardsBalance = await staking.earned(staker1.address);
    const depositShareAfterWithdraw = info.lastSharePrice
      .mul(shares)
      .div(await staking.SHARE_PRECISION());

    expect(savings).to.eq(5450); // 9000 deposit + 450 rewards - 4000 withdrawn
    expect(rewardsBalance).to.eq(0); // 449 - 190
    expect(shares).to.equal(initialShares.sub(sharesToWithdraw));
    expect(info.rewardsPaid).to.equal(450); //relative amount of withdraw from total savings multiplied by rewards earned 4000/9450 * 450 and rounded up

    await staking.withdraw(staker1.address, shares); //now withdraw everything
    info = await staking.stakersInfo(staker1.address);
    expect(await staking.sharesOf(staker1.address)).eq(0);
    expect(info.rewardsPaid).to.equal(450);
  });

  it("should update global stats after withdraw operation", async () => {
    const { staking } = await loadFixture(fixture_initOnly);
    await stake(staker1, 9000, staking);
    const statsBefore = await staking.stats();
    await advanceBlocks(BLOCKS_ONE_YEAR);

    const sharesToWithdraw = await staking.amountToShares(4000);
    await staking.withdraw(staker1.address, sharesToWithdraw);

    const statsAfter = await staking.stats();
    const initialShares = (await staking.SHARE_DECIMALS()).mul(9000);
    expect(statsAfter.lastUpdateBlock.gt(statsBefore.lastUpdateBlock));
    expect(statsAfter.totalStaked).to.equal(9000 - 4000 + 450); // 9000 - (4000 - 190 rewards component withdrawn)
    expect(await staking.sharesSupply()).to.equal(
      initialShares.sub(sharesToWithdraw)
    );
    expect(statsAfter.totalRewardsPaid).to.equal(450);
    expect(statsAfter.savings).to.equal(await staking.compoundNextBlock());
  });

  it("should compound savings over period", async () => {
    const { staking } = await loadFixture(fixture_1year);
    console.log(
      "shares:",
      await staking.balanceOf(staker1.address),
      await staking.balanceOf(staker2.address),
      await staking.balanceOf(staker3.address),
      "info:",
      await staking.stakersInfo(staker1.address),
      await staking.stakersInfo(staker2.address),
      await staking.stakersInfo(staker3.address)
    );
    let savings = await staking.getSavings(staker1.address);
    expect(savings).to.equal(10500);
    savings = await staking.getSavings(staker2.address);
    expect(savings).to.equal(10500);
    savings = await staking.getSavings(staker3.address);
    expect(savings).to.equal(10499); //bought in 2 blocks after

    let info = await staking.stakersInfo(staker1.address);
    const initialShares = (await staking.SHARE_DECIMALS()).mul(10000);
    expect(await staking.principle(staker1.address)).to.equal(10000);
    expect(await staking.balanceOf(staker1.address)).to.equal(initialShares);

    info = await staking.stakersInfo(staker2.address);
    expect(await staking.principle(staker2.address)).to.equal(9999);
    expect(await staking.balanceOf(staker2.address)).to.equal(99999999);
    expect(info.rewardsPaid).to.equal(0);

    info = await staking.stakersInfo(staker3.address);
    expect(await staking.principle(staker3.address)).to.equal(9999);
    expect(await staking.balanceOf(staker3.address)).to.equal(99999998);
    expect(info.rewardsPaid).to.equal(0);
  });

  it("should compound savings over 2 years and new staker after 1 year", async () => {
    const { staking } = await loadFixture(fixture_1year);

    //add staker after first year
    await stake(staker4, 125125, staking);
    await advanceBlocks(BLOCKS_ONE_YEAR);
    //check all stakes after 2nd year
    let savings = await staking.getSavings(staker1.address);
    expect(savings).to.equal(11025);
    savings = await staking.getSavings(staker2.address);
    expect(savings).to.equal(11025);
    savings = await staking.getSavings(staker3.address);
    expect(savings).to.equal(11025);
    savings = await staking.getSavings(staker4.address);
    expect(savings).to.equal(131381);
  });

  it("should withdraw full amount", async () => {
    const { staking } = await loadFixture(fixture_1year);
    const balance = await staking.sharesOf(staker1.address);
    await staking.withdraw(staker1.address, balance);
    const info = await staking.stakersInfo(staker1.address);

    expect(await staking.getSavings(staker1.address)).to.equal(0);
    expect(await staking.balanceOf(staker1.address)).to.equal(0);
    expect(info.rewardsPaid).to.equal(500);
  });

  it("should withdraw partial amount and calculate savings correctly after 1 year", async () => {
    const { staking } = await loadFixture(fixture_1year);
    const sharesBefore = await staking.sharesOf(staker3.address);
    //9500 withdraw / sharePrice = shares to reduce
    const expectedSharesRedeemed = await staking.amountToShares(9500);
    await staking.withdraw(staker3.address, expectedSharesRedeemed);

    const balanceAfterWithdraw = await staking.getSavings(staker3.address);
    expect(balanceAfterWithdraw).to.equal(999); //shares are not exactly 9500
    expect((await staking.stakersInfo(staker3.address)).rewardsPaid).to.eq(500);
    await advanceBlocks(BLOCKS_ONE_YEAR);

    const info = await staking.stakersInfo(staker3.address);
    const earnedRewards = await staking.earned(staker3.address);
    expect(await staking.getSavings(staker3.address)).to.equal(1049); //savings after 999 + 1 year 5%
    expect(earnedRewards).to.equal(50);

    //check shares
    expect(await staking.sharesOf(staker3.address)).to.equal(
      sharesBefore.sub(expectedSharesRedeemed)
    );
  });

  xit("should withdraw partial amount when partially donating and calculate savings correctly after 1 year", async () => {
    const { staking } = await loadFixture(fixture_1year);
    const infoBefore = await staking.stakersInfo(staker2.address);
    const expectedSharesRedeemed = await getExpectedSharesChange(
      9500 + 125,
      staking
    ); //withdrawing 9500 but 125 donated rewards will be withdrawn also

    await staking.withdraw(staker2.address, BN.from(9500)); // will withdraw 9500 from savings but also  125 donated rewards, 375 will be withdrawn from the rewards part.

    const balanceAfterWithdraw = await staking.getSavings(staker2.address);
    expect(balanceAfterWithdraw).to.equal(875); //10500 - 9500 + 125 donated

    await advanceBlocks(BLOCKS_ONE_YEAR);

    const info = await staking.stakersInfo(staker2.address);
    const [earnedRewards, earnedRewardsAfterDonations] = await staking.earned(
      staker2.address
    );
    expect(await staking.getSavings(staker2.address)).to.equal(
      907 //918 after 1 year. rewards part 43, donated 43*0.25=10.75 = 918-10.75
    ); // 875 + 5%APY * 25%donation
    expect(info.deposit).to.equal(875);
    expect(info.rewardsPaid).to.equal(375);
    expect(info.rewardsDonated).to.equal(125);
    expect(info.avgDonationRatio).to.equal((await staking.PRECISION()).mul(25));
    expect(info.shares.toNumber()).to.equal(
      infoBefore.shares.sub(expectedSharesRedeemed)
    );
    expect(
      info.shares
        .mul(await staking.sharePrice())
        .div(await staking.SHARE_PRECISION())
    ).to.equal(info.deposit.add(earnedRewards));
    expect(await staking.getSavings(staker2.address)).to.equal(
      info.deposit.add(earnedRewardsAfterDonations)
    );
  });

  xit("should withdraw partial amount when donating 100% and calculate savings correctly after 1 year", async () => {
    const { staking } = await loadFixture(fixture_1year);
    const infoBefore = await staking.stakersInfo(staker1.address);
    const expectedSharesRedeemed = await getExpectedSharesChange(
      9500 + 500,
      staking
    ); //withdrawing 9500 but 500 donated rewards will be withdrawn also

    await staking.withdraw(staker1.address, BN.from(9500)); // this will withdraw 9500 from deposit but also 500 donated rewards

    const balanceAfterWithdraw = await staking.getSavings(staker1.address);
    expect(balanceAfterWithdraw).to.equal(500);

    await advanceBlocks(BLOCKS_ONE_YEAR);

    const info = await staking.stakersInfo(staker1.address);
    const [earnedRewards, earnedRewardsAfterDonations] = await staking.earned(
      staker1.address
    );
    expect(await staking.getSavings(staker1.address)).to.equal(500);
    expect(info.deposit).to.equal(500);
    expect(info.rewardsPaid).to.equal(0);
    expect(info.rewardsDonated).to.equal(500);
    expect(info.avgDonationRatio).to.equal(
      (await staking.PRECISION()).mul(100)
    );
    expect(info.shares.toNumber()).to.equal(
      infoBefore.shares.sub(expectedSharesRedeemed)
    );
    expect(
      info.shares
        .mul(await staking.sharePrice())
        .div(await staking.SHARE_PRECISION())
    ).to.equal(info.deposit.add(earnedRewards));
    expect(await staking.getSavings(staker1.address)).to.equal(
      info.deposit.add(earnedRewardsAfterDonations)
    );
  });

  xit("should withdraw rewards from rewards only", async () => {
    const { staking } = await loadFixture(fixture_1year);
    const infoBefore = await staking.stakersInfo(staker3.address);
    const balance = await staking.getSavings(staker3.address);

    const expectedSharesRedeemed = await getExpectedSharesChange(500, staking);
    await staking.withdraw(staker3.address, 500);
    const info = await staking.stakersInfo(staker3.address);

    expect(balance).to.equal(10500); //initial stake 10000 + 5%
    expect(await staking.getSavings(staker3.address)).to.equal(10000);
    expect(info.deposit).to.equal(10000);
    expect(info.shares.toNumber()).to.equal(
      infoBefore.shares.sub(expectedSharesRedeemed)
    );
    expect(info.rewardsPaid).to.equal(500);
    expect(info.rewardsDonated).to.equal(0);
    expect(info.avgDonationRatio).to.equal(0);
  });

  xit("should update avgDonationRatio after second stake", async () => {
    const { staking } = await loadFixture(fixture_1year);
    const infoBefore = await staking.stakersInfo(staker1.address);
    const statsBefore = await staking.stats();

    await staking.stake(
      staker1.address,
      BN.from(infoBefore.shares) // staker1 buys same amount of shares he had
        .mul(await staking.sharePrice())
        .div(await staking.SHARE_PRECISION()),
      0
    );

    const infoAfter = await staking.stakersInfo(staker1.address);
    const statsAfter = await staking.stats();
    const PRECISION = await staking.PRECISION();

    expect(infoBefore.avgDonationRatio).to.equal(PRECISION.mul(100)); // 1st stake had 100% donation
    expect(infoAfter.avgDonationRatio).to.equal(PRECISION.mul(50)); // 2nd stake had 0% for same amount of shares => 50% average
    expect(statsBefore.avgDonationRatio).to.equal(PRECISION.mul(125).div(3)); // total avg of 3 stakers => 0, 25, 100 each had staked 10000
    expect(statsAfter.avgDonationRatio).to.equal(
      BN.from("31249999999999999999")
    ); // 31.25% = (2 * 0% + 1 * 25% + 1 * 100%) / 4
  });

  xit("should update avgDonationRatio after partial withdraw", async () => {
    const { staking } = await loadFixture(fixture_1year);
    const infoBeforeWithdraw = await staking.stakersInfo(staker1.address);
    const statsBeforeWithdraw = await staking.stats();
    const expectedSharesRedeemed = await getExpectedSharesChange(
      2000 + 500,
      staking
    ); //2000 + 500 that are donated
    await staking.withdraw(staker1.address, 2000); //this also withdraws the donated rewards
    const statsAfterWithdraw = await staking.stats();

    const expectedGlobalAvgRatio = statsBeforeWithdraw.avgDonationRatio
      .mul(statsBeforeWithdraw.totalShares)
      .sub(expectedSharesRedeemed.mul(infoBeforeWithdraw.avgDonationRatio))
      .div(statsAfterWithdraw.totalShares);

    const infoAfterWithdraw = await staking.stakersInfo(staker1.address);
    expect(infoBeforeWithdraw.avgDonationRatio).to.equal(
      infoAfterWithdraw.avgDonationRatio
    );

    expect(expectedGlobalAvgRatio).to.equal(
      statsAfterWithdraw.avgDonationRatio
    );
  });

  it("should calculate correct share price after savings has grown", async () => {
    const { staking } = await loadFixture(fixture_1year);
    const SHARE_PRECISION = await staking.SHARE_PRECISION();

    const savingsBefore = await staking.compound();
    const expectedSharePriceBefore = BN.from(savingsBefore)
      .mul(SHARE_PRECISION)
      .div(await staking.PRECISION())
      .div(await staking.sharesSupply());
    const actualSharePriceBefore = await staking.sharePrice();
    expect(actualSharePriceBefore).to.equal(expectedSharePriceBefore);

    await advanceBlocks(BLOCKS_ONE_YEAR);

    const savingsAfter = savingsBefore.mul(105).div(100); //estimate
    const expectedSharePriceAfter = BN.from(savingsAfter)
      .mul(SHARE_PRECISION)
      .div(await staking.PRECISION())
      .div(await staking.sharesSupply());
    const actualSharePriceAfter = await staking.sharePrice();
    expect(actualSharePriceAfter.div(1e8)).to.eq(
      expectedSharePriceAfter.div(1e8)
    ); //compare rough estimate so we reduce precision by 1e8
  });

  it("should check compound function compounds savings correctly", async () => {
    const { staking } = await loadFixture(fixture_1year);
    const PRECISION = await staking.PRECISION();

    const expectedCompoundBefore = 3 * 10000 * 1.05; // 3 stakers of 10000 with 5 APY, after one year
    const actualCompoundBefore = (await staking.compound()).div(PRECISION);
    expect(actualCompoundBefore).to.equal(expectedCompoundBefore);

    await advanceBlocks(BLOCKS_ONE_YEAR);

    const expectedCompoundAfter = expectedCompoundBefore * 1.05;
    const actualCompoundAfter = (await staking.compound()).div(PRECISION);
    expect(actualCompoundAfter).to.equal(expectedCompoundAfter);
    expect(actualCompoundAfter.gt(actualCompoundBefore)).to.be.true;
  });

  it("should calculate earned rewards in period", async () => {
    const { staking } = await loadFixture(fixture_1year);
    let earnedRewards1 = await staking.earned(staker1.address);
    let earnedRewards2 = await staking.earned(staker2.address);
    let earnedRewards3 = await staking.earned(staker3.address);

    expect(earnedRewards1).equal(earnedRewards2).equal(500);
    expect(earnedRewards3).eq(499);

    await advanceBlocks(BLOCKS_ONE_YEAR);
    earnedRewards1 = await staking.earned(staker1.address);
    earnedRewards2 = await staking.earned(staker2.address);
    earnedRewards3 = await staking.earned(staker3.address);

    expect(earnedRewards1)
      .equal(earnedRewards2)
      .equal(earnedRewards3)
      .equal(1025);
  });

  it("Should undo reward part and update staker info", async () => {
    const { staking } = await loadFixture(fixture_1year);

    const initialInfo = await staking.stakersInfo(staker3.address);
    const sharesToWithdraw = await staking.amountToShares(500);
    const initialRewards = await staking.earned(staker3.address);
    await staking.withdrawAndUndo(staker3.address, sharesToWithdraw);

    const infoAfterUndo = await staking.stakersInfo(staker3.address);

    expect(await staking.getSavings(staker3.address)).to.equal(10499);

    expect(await staking.earned(staker3.address)).to.eq(500);
    expect(infoAfterUndo.rewardsPaid).to.equal(initialInfo.rewardsPaid);
  });

  it("Should undo reward and keep global stats the same", async () => {
    const { staking } = await loadFixture(fixture_1year);

    const initialStats = await staking.stats();

    const initialSavings = await staking.compoundNextBlock(); //withdrawAndUndo will calculate savings of next block
    const sharesToWithdraw = await staking.amountToShares(500);
    const initialShares = await staking.sharesSupply();
    await staking.withdrawAndUndo(staker3.address, sharesToWithdraw);
    const statsAfterUndo = await staking.stats();

    expect(statsAfterUndo.savings.div(ethers.constants.WeiPerEther)).to.equal(
      31500
    );

    expect(initialStats.totalRewardsPaid).to.equal(
      statsAfterUndo.totalRewardsPaid
    );

    expect(await staking.sharesSupply()).to.lt(initialShares);
    expect(initialStats.totalStaked).to.equal(statsAfterUndo.totalStaked);
  });

  xit("Should undo reward when part of them is donated and keep info and global stats the same", async () => {
    const { staking } = await loadFixture(fixture_1year);

    const initialStats = await staking.stats();
    const initialInfo = await staking.stakersInfo(staker2.address);
    const initialSavings = await staking.getSavings(staker2.address);
    const latestSavings = await staking.compoundNextBlock(); //withdrawAndUndo will calculate savings of next block

    await staking.withdrawAndUndo(staker2.address, 375); //375 rewards 125 donated

    const infoAfterUndo = await staking.stakersInfo(staker2.address);
    expect(await staking.getSavings(staker2.address)).to.equal(initialSavings);
    expect(infoAfterUndo.rewardsPaid).to.equal(0);
    expect(infoAfterUndo.rewardsDonated).to.equal(0);

    expect(infoAfterUndo.avgDonationRatio).to.equal(
      initialInfo.avgDonationRatio
    );
    expect(initialInfo.shares).to.eq(infoAfterUndo.shares);

    //check global stats
    const statsAfterUndo = await staking.stats();

    expect(statsAfterUndo.savings).to.equal(latestSavings);

    expect(initialStats.totalRewardsDonated).to.equal(
      statsAfterUndo.totalRewardsDonated
    );
    expect(initialStats.totalRewardsPaid).to.equal(
      statsAfterUndo.totalRewardsPaid
    );
    expect(initialStats.totalShares).to.equal(statsAfterUndo.totalShares);
    expect(initialStats.totalStaked).to.equal(statsAfterUndo.totalStaked);
    expect(initialStats.avgDonationRatio).to.equal(
      statsAfterUndo.avgDonationRatio.add(1) //precision loss during withdraw avgDonationRatio calculation
    );
  });

  it("Should undo reward when withdrawing partial rewards keep info and global stats the same", async () => {
    const { staking } = await loadFixture(fixture_1year);

    const initialInfo = await staking.stakersInfo(staker2.address);
    const initialSavings = await staking.getSavings(staker2.address);
    const initialStats = await staking.stats();
    const initialTotalSavings = await staking.compoundNextBlock(); //withdrawAndUndo will calculate savings of next block
    const initialSharesSupply = await staking.sharesSupply();
    //current rewards are 500 so 250 is only partial withdraw of rewards
    const sharesToWithdraw = await staking.amountToShares(250);
    await staking.withdrawAndUndo(staker2.address, sharesToWithdraw);

    const infoAfterUndo = await staking.stakersInfo(staker2.address);
    expect(await staking.getSavings(staker2.address)).to.equal(initialSavings);
    expect(infoAfterUndo.rewardsPaid).to.equal(initialInfo.rewardsPaid);

    //check global stats
    const statsAfterUndo = await staking.stats();

    expect(statsAfterUndo.savings).to.equal(initialTotalSavings);

    expect(initialStats.totalRewardsDonated).to.equal(
      statsAfterUndo.totalRewardsDonated
    );
    expect(initialStats.totalRewardsPaid).to.equal(
      statsAfterUndo.totalRewardsPaid
    );
    expect(initialSharesSupply).to.equal((await staking.sharesSupply()).add(1)); //precision loss when converting back from rewards amount to shares
    expect(initialStats.totalStaked).to.equal(statsAfterUndo.totalStaked);
  });

  //helper test
  // it.only("Should not suffer from endless precission loss", async () => {
  //   const { staking } = await loadFixture(fixture_1year_single);

  //   const initialShares = await staking.sharesOf(staker3.address);
  //   const maxLoss = await staking.amountToShares(1);
  //   for (let i = 0; i < 500; i++) {
  //     expect(await staking.getSavings(staker3.address)).eq(10500);
  //     expect(await staking.sharesOf(staker3.address)).gte(
  //       initialShares.sub(maxLoss)
  //     );
  //     expect(await staking.earned(staker3.address)).eq(500);
  //     const sharesToWithdraw = await staking.amountToShares(500);
  //     await staking.withdrawAndUndo(staker3.address, sharesToWithdraw);
  //   }
  // });

  xit("Should undo reward when withdrawing rewards + deposit and update deposit info and stats correctly", async () => {});

  it("Should be able to withdraw right after staking", async () => {
    const { staking } = await loadFixture(fixture_1year);
    await stake(staker4, 10000, staking);
    await expect(
      staking.withdraw(
        staker4.address,
        await staking.balanceOf(staker4.address)
      )
    ).not.reverted;

    const info = await staking.stakersInfo(staker4.address);
    expect(await staking.getSavings(staker4.address)).to.equal(0);
    expect(info.rewardsPaid).to.equal(0);
    expect(info.lastSharePrice.div(1e8)).to.equal(
      (await staking.sharePrice()).div(1e8)
    );
  });

  it("should calculate savings correctly after set APY ", async () => {
    const { staking } = await loadFixture(fixture_1year);
    await stake(staker4, 125125, staking);

    // before set, APY is 5%
    const beforeSetInterestRateIn128 = await staking.interestRatePerBlockX64();
    expect(beforeSetInterestRateIn128).to.equal(INTEREST_RATE_5APY_128);

    // set APY to 10%
    await staking.setAPY(INTEREST_RATE_10APY_X64);
    await advanceBlocks(BLOCKS_ONE_YEAR);

    await expectSavings(staker1, 11550, staking);
    await expectSavings(staker2, 11550, staking);
    await expectSavings(staker3, 11550, staking); // 10000 + 10000((1.05APY1 * 1.10APY2) - 1)
    await expectSavings(staker4, 137637, staking); // 125125((1.10APY2) - 1)

    // set APY to 8%
    await staking.setAPY(INTEREST_RATE_8APY_X64);
    await advanceBlocks(BLOCKS_ONE_YEAR);

    await expectSavings(staker1, 12474, staking);
    await expectSavings(staker2, 12474, staking);
    await expectSavings(staker3, 12474, staking);
    await expectSavings(staker4, 148648, staking); // 125125((1.10APY2 * 1.08APY3) - 1)
  });

  it("should handle first stake big, followed by smaller actions", async () => {
    const { staking } = await loadFixture(fixture_2);

    await stake(staker4, 10000000, staking);

    const savingsAfterBigStake = await staking.getSavings(staker4.address);
    const infoAfterBigStake = await staking.stakersInfo(staker4.address);
    await stake(signers[0], 5, staking);

    const savingsAfterSmallStake = await staking.getSavings(staker4.address);
    const smallStakeSavings = await staking.getSavings(signers[0].address);
    expect(smallStakeSavings).gt(0);
    const sharesAfterBigStake = await staking.balanceOf(staker4.address);

    const sharesAfterSmallStake = await staking.balanceOf(signers[0].address);
    expect(savingsAfterSmallStake.eq(savingsAfterBigStake)).to.be.true;
    expect(sharesAfterSmallStake).gt(0);

    const onegdShares = await staking.amountToShares(1);
    await expect(staking.withdraw(staker4.address, 1000)).revertedWith(/min/);

    await expect(staking.withdraw(staker4.address, onegdShares)).not.reverted;
    await expect(
      staking.withdraw(
        signers[0].address,
        await staking.balanceOf(signers[0].address)
      )
    ).not.reverted;

    const sharesAfterWithdraw = await staking.balanceOf(staker4.address);
    const sharesAfterWithdraw2 = await staking.balanceOf(signers[0].address);

    expect(sharesAfterWithdraw).to.equal(sharesAfterBigStake.sub(onegdShares));
    expect(sharesAfterWithdraw2).to.equal(0);
  });

  it("should handle first stake small, followed by 100 Billion stake", async () => {
    const { staking } = await loadFixture(fixture_2);

    await stake(signers[0], 5, staking);
    await stake(staker4, 1e13, staking);

    const onegdShares = await staking.amountToShares(1);
    await staking.withdraw(staker4.address, onegdShares);

    await expect(
      staking.withdraw(
        signers[0].address,
        await staking.balanceOf(signers[0].address)
      )
    ).not.reverted;
  });

  it("should handle first 100 Billion stake, followed by a small", async () => {
    const { staking } = await loadFixture(fixture_2);

    await stake(staker4, 1e13, staking);
    await stake(signers[0], 5, staking);

    const onegdShares = await staking.amountToShares(1);
    await expect(
      staking.withdraw(
        signers[0].address,
        await staking.balanceOf(signers[0].address)
      )
    ).not.reverted;
    await expect(staking.withdraw(staker4.address, onegdShares)).not.reverted;
  });

  xit("should withdraw all when amount=max uint", async () => {
    const { staking } = await loadFixture(fixture_1year);
    await expect(staking.withdraw(staker3.address, 0)).revertedWith(/balance/);
    await staking.withdraw(staker3.address, ethers.constants.MaxUint256);
    const info = await staking.stakersInfo(staker3.address);

    expect(info.rewardsPaid).to.equal(499);
    expect(await staking.sharesOf(staker3.address)).to.equal(0);
    expect(await staking.getSavings(staker3.address)).to.equal(0);
  });

  it("should be able to get rewards debt (ie savings - deposits - donated rewards)", async () => {
    const { staking } = await loadFixture(fixture_1year);
    const debt = (await staking.getRewardsDebt()).div(
      ethers.utils.parseEther("1")
    ); //debt is in 1e18 precision
    expect(debt).to.equal(1500); //30000*1.05 - 300000
  });

  it("should not be able to stake less than share price", async () => {
    const { staking } = await loadFixture(fixture_1year);
    await advanceBlocks(BLOCKS_TEN_YEARS * 20);

    await expect(stake(staker1, 1, staking)).to.revertedWith(/share/);
    await expect(stake(staker1, 2, staking)).to.not.reverted;
  });

  it("should not be able to withdraw less than share price", async () => {
    const { staking } = await loadFixture(fixture_1year);
    await advanceBlocks(BLOCKS_TEN_YEARS * 10);

    const sharePrice = await staking.sharePrice();
    await expect(staking.withdraw(staker3.address, 1)).to.revertedWith(/share/);
  });

  it("should handle stake/withdraw for 1 Trillion staked for 50 years", async () => {
    const { staking } = await loadFixture(fixture_1year);
    await stake(staker3, 100000000000000, staking);
    await advanceBlocks(BLOCKS_TEN_YEARS * 5);

    await expect(
      staking.withdraw(
        staker3.address,
        await staking.balanceOf(staker3.address)
      )
    ).to.not.reverted;
  });

  it("should have undo reward handle invalid input", async () => {
    const staking: StakingMockFixedAPY = (await (
      await ethers.getContractFactory("StakingMockFixedAPY")
    ).deploy(INTEREST_RATE_5APY_X64)) as StakingMockFixedAPY;

    //undo 0 rewards
    await stake(staker4, 10000, staking);
    await staking.withdraw(
      staker4.address,
      await staking.balanceOf(staker4.address)
    );
    await expect(staking.undoReward(staker4.address, 0)).to.not.reverted;
  });
});