@gooddollar/goodprotocol 1.0.7-beta.2 → 1.0.9-beta.0

package/test/helpers.ts

@@ -18,7 +18,11 @@ import { GoodMarketMaker, CompoundVotingMachine } from "../types";
 import { Contract } from "ethers";
 
 export const getStakingFactory = async (
-  factory: "GoodCompoundStaking" | "GoodAaveStaking" | "GoodCompoundStakingTest"
+  factory:
+    | "GoodCompoundStaking"
+    | "GoodAaveStaking"
+    | "GoodCompoundStakingTest"
+    | "GoodAaveStakingV2"
 ) => {
   let swapHelper = await ethers
     .getContractFactory("UniswapV2SwapHelper")

package/test/staking/GoodAaveStakingFactoryV2.test.ts

@@ -0,0 +1,122 @@
+import { default as hre, ethers, upgrades } from "hardhat";
+import { deployMockContract, MockContract } from "ethereum-waffle";
+import { expect } from "chai";
+import { CERC20, GoodAaveStaking, AaveStakingFactory } from "../../types";
+import { createDAO, deployUniswap } from "../helpers";
+import { Contract } from "ethers";
+
+const BN = ethers.BigNumber;
+export const NULL_ADDRESS = ethers.constants.AddressZero;
+
+let cdai: CERC20;
+
+describe("AaveStakingFactoryV2", () => {
+  let founder,
+    signers,
+    cdai,
+    usdc,
+    aave,
+    incentiveController,
+    aaveUsdOracle: Contract,
+    dai,
+    dao,
+    stakingFactory: AaveStakingFactory,
+    lendingPool: Contract;
+
+  before(async () => {
+    [founder, ...signers] = await ethers.getSigners();
+    dao = await createDAO();
+    const usdcFactory = await ethers.getContractFactory("USDCMock");
+    const lendingPoolFactory = await ethers.getContractFactory(
+      "LendingPoolMock"
+    );
+    aave = await (await ethers.getContractFactory("AaveMock")).deploy();
+    incentiveController = await (
+      await ethers.getContractFactory("IncentiveControllerMock")
+    ).deploy(aave.address);
+    usdc = await usdcFactory.deploy();
+    lendingPool = await lendingPoolFactory.deploy(usdc.address);
+    aaveUsdOracle = await (
+      await ethers.getContractFactory("AaveUSDMockOracle")
+    ).deploy();
+    dai = dao.daiAddress;
+    cdai = dao.cdaiAddress;
+    const uniswap = await deployUniswap(
+      dao.COMP,
+      await ethers.getContractAt("DAIMock", dai)
+    );
+    const router = uniswap.router;
+    await dao.setDAOAddress("UNISWAP_ROUTER", router.address);
+    await dao.setDAOAddress("AAVE", aave.address);
+    let swapHelper = await ethers
+      .getContractFactory("UniswapV2SwapHelper")
+      .then(_ => _.deploy());
+
+    stakingFactory = (await ethers
+      .getContractFactory("AaveStakingFactoryV2", {
+        libraries: { UniswapV2SwapHelper: swapHelper.address }
+      })
+      .then(_ => _.deploy())) as AaveStakingFactory;
+  });
+
+  it("should create proxy clone", async () => {
+    const res = await (
+      await stakingFactory.clone(usdc.address, ethers.constants.HashZero)
+    ).wait();
+    const log = res.events.find(_ => _.event === "Deployed");
+    const detAddress = await stakingFactory.predictAddress(
+      usdc.address,
+      ethers.constants.HashZero
+    );
+
+    expect(log).to.not.empty;
+    expect(log.args.proxy).to.equal(detAddress);
+    expect(log.args.token).to.equal(usdc.address);
+  });
+
+  it("should create and initialize clone", async () => {
+    const ns = await ethers
+      .getContractFactory("NameService")
+      .then(_ => _.deploy());
+    const res = await (
+      await stakingFactory.cloneAndInit(
+        usdc.address,
+        lendingPool.address,
+        dao.nameService.address,
+        5760,
+        stakingFactory.address,
+        incentiveController.address,
+        aaveUsdOracle.address,
+        [usdc.address, dai]
+      )
+    ).wait();
+    const log = res.events.find(_ => _.event === "Deployed");
+    const detAddress = await stakingFactory.predictAddress(
+      usdc.address,
+      ethers.utils.solidityKeccak256(
+        ["address", "address", "uint64", "address", "address", "address"],
+        [
+          lendingPool.address,
+          dao.nameService.address,
+          5760,
+          stakingFactory.address,
+          incentiveController.address,
+          aaveUsdOracle.address
+        ]
+      )
+    );
+    expect(log).to.not.empty;
+    expect(log.args.proxy).to.equal(detAddress);
+    expect(log.args.token).to.equal(usdc.address);
+
+    //check initialization
+    const staking: GoodAaveStaking = (await ethers.getContractAt(
+      "GoodAaveStaking",
+      detAddress
+    )) as GoodAaveStaking;
+    expect(await staking.iToken()).to.equal(lendingPool.address);
+    expect(await staking.token()).to.equal(usdc.address);
+    expect(await staking.name()).to.equal("GoodAaveStakingV2 aUSDC");
+    expect(await staking.symbol()).to.equal("gaUSDC");
+  });
+});

package/test/staking/UsdcAaveStaking.test.ts

@@ -29,6 +29,7 @@ describe("UsdcAaveStaking - staking with USDC mocks to AAVE interface", () => {
     lendingPool,
     setDAOAddress,
     genericCall,
+    goodReserve,
     goodAaveStakingFactory;
   before(async () => {
     [founder, staker, ...signers] = await ethers.getSigners();
@@ -55,8 +56,10 @@ describe("UsdcAaveStaking - staking with USDC mocks to AAVE interface", () => {
       marketMaker: mm,
       daiAddress,
       genericCall: gc,
-      COMP
+      COMP,
+      reserve
     } = await createDAO();
+    goodReserve = reserve;
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     avatar = av;
     controller = ctrl;
@@ -275,6 +278,7 @@ describe("UsdcAaveStaking - staking with USDC mocks to AAVE interface", () => {
     );
     expect(currentGainsAfterEarnRewards[4]).to.be.equal(0); // stkAAVE rewards shouldnt count as gain
     expect(currentGainsAfterCollectInterest[4]).to.be.equal("0");
+    expect(await aave.balanceOf(goodReserve.address)).gt(0);
   });
   async function addLiquidity(
     token0: Contract,

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

package/truffle-config.js

@@ -70,6 +70,18 @@ module.exports = {
       timeoutBlocks: 200, // # of blocks before a deployment times out  (minimum/default: 50)
       skipDryRun: true // Skip dry run before migrations? (default: false for public nets )
     },
+    ropsten: {
+      provider: () =>
+        new HDWalletProvider(
+          mnemonic,
+          `https://ropsten.infura.io/v3/YOUR-PROJECT-ID`
+        ),
+      network_id: 3, // Ropsten's id
+      gas: 5000000, // Ropsten has a lower block limit than mainnet
+      confirmations: 2, // # of confs to wait between deployments. (default: 0)
+      timeoutBlocks: 200, // # of blocks before a deployment times out  (minimum/default: 50)
+      skipDryRun: true // Skip dry run before migrations? (default: false for public nets )
+    },
     fuse: {
       provider: () => new HDWalletProvider(mnemonic, `https://rpc.fuse.io`),
       network_id: 122, // Ropsten's id