@gooddollar/goodprotocol 1.0.9 → 1.0.13-beta.0

package/contracts/staking/aave/AaveStakingFactoryV2.sol

@@ -1,93 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity >=0.8.0;
-import "@openzeppelin/contracts-upgradeable/proxy/ClonesUpgradeable.sol";
-import "./GoodAaveStakingV2.sol";
-import "../../Interfaces.sol";
-
-/**
- * @title Staking contract that donates earned interest to the DAO
- * allowing stakers to deposit Token
- * or withdraw their stake in Token
- * the contracts buy cToken and can transfer the daily interest to the  DAO
- */
-contract AaveStakingFactoryV2 {
-	using ClonesUpgradeable for address;
-
-	address public impl = address(new GoodAaveStakingV2());
-
-	event Deployed(address proxy, address token);
-
-	function clone(ERC20 token, bytes32 paramsHash)
-		public
-		returns (GoodAaveStakingV2)
-	{
-		address deployed = address(impl).cloneDeterministic(
-			keccak256(abi.encodePacked(address(token), paramsHash))
-		);
-		emit Deployed(deployed, address(token));
-		return GoodAaveStakingV2(deployed);
-	}
-
-	/**
-	@dev Function to clone Staking contract and initialize new one with new token
-	@param token Staking token to use in staking contract
-	@param _lendingPool address of the lending Pool of AAVE Protocol
-	@param _ns NameService that holds whole necessary addresses
-	@param _maxRewardThreshold Block numbers that need to pass in order to user would get their rewards with 1x multiplier instead of 0.5x
-	@param _tokenUsdOracle address of the TOKEN/USD oracle
-	@param _incentiveController Incentive Controller of AAVE protocol in order to claim rewards from AAVE
-	@param _aaveUSDOracle address of the AAVE/USD oracle
-	 */
-	function cloneAndInit(
-		ERC20 token,
-		address _lendingPool,
-		INameService _ns,
-		uint64 _maxRewardThreshold,
-		address _tokenUsdOracle,
-		IAaveIncentivesController _incentiveController,
-		address _aaveUSDOracle,
-		address[] memory _tokenToDaiSwapPath
-	) public {
-		GoodAaveStakingV2 deployed = clone(
-			token,
-			keccak256(
-				abi.encodePacked(
-					_lendingPool,
-					address(_ns),
-					_maxRewardThreshold,
-					_tokenUsdOracle,
-					address(_incentiveController),
-					_aaveUSDOracle
-				)
-			)
-		);
-
-		ERC20 iToken = ERC20(
-			ILendingPool(_lendingPool).getReserveData(address(token)).aTokenAddress
-		);
-		deployed.init(
-			address(token),
-			address(_lendingPool),
-			_ns,
-			string(abi.encodePacked("GoodAaveStakingV2 ", iToken.name())),
-			string(abi.encodePacked("g", iToken.symbol())),
-			_maxRewardThreshold,
-			_tokenUsdOracle,
-			_incentiveController,
-			_aaveUSDOracle,
-			_tokenToDaiSwapPath
-		);
-	}
-
-	function predictAddress(ERC20 token, bytes32 paramsHash)
-		public
-		view
-		returns (address)
-	{
-		return
-			address(impl).predictDeterministicAddress(
-				keccak256(abi.encodePacked(address(token), paramsHash))
-			);
-	}
-}

package/test/staking/GoodAaveStakingFactoryV2.test.ts

@@ -1,122 +0,0 @@
-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/UsdcAaveStakingV2.test.ts

@@ -1,291 +0,0 @@
-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);
-  }
-});