@gooddollar/goodprotocol 1.0.7 → 1.0.10

package/test/staking/UsdcAaveStakingV2.test.ts

@@ -0,0 +1,291 @@
+import { default as hre, ethers, upgrades } from "hardhat";
+import { BigNumber, Contract } from "ethers";
+import { expect } from "chai";
+import { GoodMarketMaker } from "../../types";
+import IUniswapV2Pair from "@uniswap/v2-core/build/IUniswapV2Pair.json";
+import { createDAO, deployUniswap, getStakingFactory } from "../helpers";
+
+const BN = ethers.BigNumber;
+export const NULL_ADDRESS = ethers.constants.AddressZero;
+
+describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () => {
+  let dai: Contract;
+  let usdc: Contract;
+  let pair: Contract, uniswapRouter: Contract;
+  let comp: Contract, aave: Contract;
+  let daiUsdOracle: Contract, aaveUsdOracle: Contract;
+  let goodAaveStaking: Contract;
+  let goodFundManager: Contract;
+  let avatar,
+    goodDollar,
+    marketMaker: GoodMarketMaker,
+    controller,
+    founder,
+    staker,
+    schemeMock,
+    signers,
+    nameService,
+    incentiveController,
+    lendingPool,
+    setDAOAddress,
+    genericCall,
+    goodAaveStakingFactory;
+  before(async () => {
+    [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,
+      gd,
+      identity,
+      nameService: ns,
+      setDAOAddress: sda,
+      marketMaker: mm,
+      daiAddress,
+      genericCall: gc,
+      COMP
+    } = await createDAO();
+    dai = await ethers.getContractAt("DAIMock", daiAddress);
+    avatar = av;
+    controller = ctrl;
+    setDAOAddress = sda;
+    nameService = ns;
+    genericCall = gc;
+    console.log("deployed dao", {
+      founder: founder.address,
+      gd,
+      identity,
+      controller,
+      avatar
+    });
+    goodFundManager = await upgrades.deployProxy(
+      goodFundManagerFactory,
+      [nameService.address],
+      { kind: "uups" }
+    );
+    await setDAOAddress("FUND_MANAGER", goodFundManager.address);
+    console.log("Deployed goodfund manager", {
+      manager: goodFundManager.address
+    });
+    goodDollar = await ethers.getContractAt("IGoodDollar", gd);
+
+    marketMaker = mm;
+    const tokenUsdOracleFactory = await ethers.getContractFactory(
+      "BatUSDMockOracle"
+    );
+    daiUsdOracle = await tokenUsdOracleFactory.deploy();
+    comp = COMP;
+    usdc = await usdcFactory.deploy(); // Another erc20 token for uniswap router test
+    const uniswap = await deployUniswap(comp, dai);
+    uniswapRouter = uniswap.router;
+    const { factory, weth } = uniswap;
+    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(
+      pairAddress,
+      JSON.stringify(IUniswapV2Pair.abi),
+      staker
+    ).connect(founder);
+    aave = await (await ethers.getContractFactory("AaveMock")).deploy();
+    await factory.createPair(aave.address, dai.address);
+    const aavePairAddress = factory.getPair(aave.address, dai.address);
+    const aavePair = new Contract(
+      aavePairAddress,
+      JSON.stringify(IUniswapV2Pair.abi),
+      staker
+    ).connect(founder);
+    await dai["mint(address,uint256)"](
+      founder.address,
+      ethers.utils.parseEther("500000000000000")
+    );
+    await aave["mint(address,uint256)"](
+      founder.address,
+      ethers.utils.parseEther("20000")
+    );
+    await addLiquidity(
+      dai,
+      aave,
+      aavePair,
+      ethers.utils.parseEther("2000000"),
+      ethers.utils.parseEther("2000")
+    );
+
+    await setDAOAddress("COMP", comp.address);
+
+    lendingPool = await lendingPoolFactory.deploy(usdc.address);
+    incentiveController = await (
+      await ethers.getContractFactory("IncentiveControllerMock")
+    ).deploy(aave.address);
+    aaveUsdOracle = await (
+      await ethers.getContractFactory("AaveUSDMockOracle")
+    ).deploy();
+    await setDAOAddress("AAVE", aave.address);
+    goodAaveStaking = 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;
+      });
+    await usdc["mint(address,uint256)"](
+      founder.address,
+      ethers.utils.parseUnits("500000000000000", 6)
+    );
+    await usdc["mint(address,uint256)"](
+      staker.address,
+      ethers.utils.parseUnits("10000", 6)
+    );
+    await usdc["mint(address,uint256)"](
+      lendingPool.address,
+      ethers.utils.parseEther("100000000")
+    ); // We should put extra USDC to LendingPool/Atoken contract in order to provide interest
+    await addLiquidity(
+      usdc,
+      dai,
+      pair,
+      ethers.utils.parseUnits("200000000000000", 6),
+      ethers.utils.parseEther("200000000000000")
+    );
+    await usdc.approve(goodAaveStaking.address, ethers.constants.MaxUint256);
+    await usdc
+      .connect(staker)
+      .approve(goodAaveStaking.address, ethers.constants.MaxUint256);
+    const currentBlockNumber = await ethers.provider.getBlockNumber();
+    const encodedData = goodFundManagerFactory.interface.encodeFunctionData(
+      "setStakingReward",
+      [
+        "1000",
+        goodAaveStaking.address,
+        currentBlockNumber - 5,
+        currentBlockNumber + 500,
+        false
+      ] // set 10 gd per block
+    );
+    await genericCall(goodFundManager.address, encodedData, avatar, 0);
+    await setDAOAddress("MARKET_MAKER", marketMaker.address);
+  });
+
+  it("it should stake usdc to lendingPool and withdraw", async () => {
+    const stakingAmount = ethers.utils.parseUnits("100", 6);
+    await goodAaveStaking.stake(stakingAmount, 0, false);
+    const aTokenBalanceAfterStake = await lendingPool.balanceOf(
+      goodAaveStaking.address
+    );
+    await goodAaveStaking.withdrawStake(stakingAmount, false);
+    const aTokenBalanceAfterWithdraw = await lendingPool.balanceOf(
+      goodAaveStaking.address
+    );
+    expect(aTokenBalanceAfterWithdraw).to.be.equal(0);
+    expect(aTokenBalanceAfterStake).to.be.gt(0);
+    expect(aTokenBalanceAfterStake).to.be.equal(stakingAmount);
+  });
+
+  it("stake should generate some interest and should be used to generate UBI", async () => {
+    const stakingAmount = ethers.utils.parseUnits("100", 6);
+
+    await goodAaveStaking.connect(staker).stake(stakingAmount, 0, false);
+
+    await lendingPool.giveInterestToUser("1500", goodAaveStaking.address); // increase interest by calling giveInterestToUser
+
+    const currentUBIInterestBeforeWithdraw = await goodAaveStaking.currentGains(
+      false,
+      true
+    );
+    await goodAaveStaking.connect(staker).withdrawStake(stakingAmount, false);
+    const gdBalanceBeforeCollectInterest = await goodDollar.balanceOf(
+      staker.address
+    );
+    const contractAddressesToBeCollected =
+      await goodFundManager.calcSortedContracts();
+    console.log(contractAddressesToBeCollected.toString());
+    const addressesToCollect = contractAddressesToBeCollected.map(x => x[0]);
+    await goodFundManager
+      .connect(staker)
+      .collectInterest(addressesToCollect, false);
+    const gdBalanceAfterCollectInterest = await goodDollar.balanceOf(
+      staker.address
+    );
+    const currentUBIInterestAfterWithdraw = await goodAaveStaking.currentGains(
+      false,
+      true
+    );
+    expect(currentUBIInterestBeforeWithdraw[0].toString()).to.not.be.equal("0");
+    expect(currentUBIInterestAfterWithdraw[0].toString()).to.be.equal("0");
+    expect(gdBalanceAfterCollectInterest.gt(gdBalanceBeforeCollectInterest));
+  });
+
+  it("it should not collect stkAAVE when collecting interest", async () => {
+    const stakingAmount = ethers.utils.parseUnits("100", 6);
+    await goodAaveStaking.stake(stakingAmount, "0", false);
+    const currentGainsAfterStake = await goodAaveStaking.currentGains(
+      false,
+      true
+    );
+    await incentiveController.increaseRewardsBalance(
+      goodAaveStaking.address,
+      ethers.utils.parseEther("10")
+    );
+    const currentGainsAfterEarnRewards = await goodAaveStaking.currentGains(
+      false,
+      true
+    );
+    await lendingPool.giveInterestToUser(2000, goodAaveStaking.address);
+    const currentGainsAfterGetInterest = await goodAaveStaking.currentGains(
+      false,
+      true
+    );
+    const contractAddressesToBeCollected = await goodFundManager
+      .connect(staker)
+      .calcSortedContracts();
+    const addressesToCollect = contractAddressesToBeCollected.map(x => x[0]);
+    await goodFundManager.collectInterest(addressesToCollect, false, {
+      gasLimit: 1200000
+    });
+    const currentGainsAfterCollectInterest = await goodAaveStaking.currentGains(
+      false,
+      true
+    );
+    await goodAaveStaking.withdrawStake(stakingAmount, false);
+    expect(currentGainsAfterStake[4]).to.be.equal("0");
+    expect(currentGainsAfterGetInterest[4]).to.be.gt(
+      currentGainsAfterEarnRewards[4]
+    );
+    expect(currentGainsAfterEarnRewards[4]).to.be.equal(0); // stkAAVE rewards shouldnt count as gain
+    expect(currentGainsAfterCollectInterest[4]).to.be.equal("0");
+    expect(await aave.balanceOf(avatar)).gt(0);
+  });
+  async function addLiquidity(
+    token0: Contract,
+    token1: Contract,
+    pair: Contract,
+    token0Amount: BigNumber,
+    token1Amount: BigNumber
+  ) {
+    await token0.transfer(pair.address, token0Amount);
+    await token1.transfer(pair.address, token1Amount);
+    await pair.mint(founder.address);
+  }
+});