@gooddollar/goodprotocol 1.0.18 → 1.0.19-beta.2

package/test/reserve/GoodReserveCDai.gdx.test.ts

@@ -8,6 +8,8 @@ import { createDAO, increaseTime, advanceBlocks } from "../helpers";
 import ContributionCalculation from "@gooddollar/goodcontracts/stakingModel/build/contracts/ContributionCalculation.json";
 
 const BN = ethers.BigNumber;
+const RANDOM_GDX_MERKLEROOT1 = 
+  "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 export const NULL_ADDRESS = ethers.constants.AddressZero;
 export const BLOCK_INTERVAL = 1;
 
@@ -25,7 +27,9 @@ describe("GDX Token", () => {
     staker,
     schemeMock,
     signers,
-    setDAOAddress;
+    genericCall,
+    setDAOAddress,
+    runAsAvatarOnly;
 
   before(async () => {
     [founder, staker, ...signers] = await ethers.getSigners();
@@ -44,6 +48,8 @@ describe("GDX Token", () => {
       marketMaker: mm,
       daiAddress,
       cdaiAddress,
+      genericCall: gn,
+      runAsAvatarOnly: raao
     } = await createDAO();
 
     dai = await ethers.getContractAt("DAIMock", daiAddress);
@@ -53,7 +59,9 @@ describe("GDX Token", () => {
     controller = ctrl;
     setDAOAddress = sda;
     goodReserve = reserve as GoodReserveCDai;
-
+    genericCall = gn;
+    runAsAvatarOnly = raao;
+    
     console.log("deployed dao", {
       founder: founder.address,
       gd,
@@ -93,13 +101,8 @@ describe("GDX Token", () => {
       "setContributionRatio",
       [nom, denom]
     );
-    const ictrl = await ethers.getContractAt(
-      "Controller",
-      controller,
-      schemeMock
-    );
 
-    await ictrl.genericCall(contribution.address, encodedCall, avatar, 0);
+    await genericCall(contribution.address, encodedCall);
   });
 
   it("should have only role of admin assigned to avatar", async () => {
@@ -253,6 +256,18 @@ describe("GDX Token", () => {
     );
   });
 
+  it("should set GDX airdrop by avatar", async () => {
+    await runAsAvatarOnly(goodReserve,"setGDXAirdrop(bytes32)", RANDOM_GDX_MERKLEROOT1);
+    expect(await goodReserve.gdxAirdrop()).to.equal(RANDOM_GDX_MERKLEROOT1);
+    
+    const originalGDXAirdrop = "0x26ef809f3f845395c0bc66ce1eea85146516cb99afd030e2085b13e79514e94c";
+    const encodedCall = goodReserve.interface.encodeFunctionData(
+      "setGDXAirdrop",
+      [originalGDXAirdrop]
+    );
+    await genericCall(goodReserve.address, encodedCall);
+  });
+
   //check sample proof generated by gdxAirdropCalculation.ts script
   it("should be able to claim gdx", async () => {
     await goodReserve.claimGDX(

package/test/reserve/GoodReserveCDai.test.ts

@@ -28,7 +28,8 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     signers,
     exchangeHelper: Contract,
     setDAOAddress,
-    nameService;
+    nameService,
+    runAsAvatarOnly;
 
   before(async () => {
     [founder, staker, ...signers] = await ethers.getSigners();
@@ -46,7 +47,8 @@ describe("GoodReserve - staking with cDAI mocks", () => {
       marketMaker: mm,
       daiAddress,
       cdaiAddress,
-      reserve
+      reserve,
+      runAsAvatarOnly: raao,
     } = await createDAO();
 
     dai = await ethers.getContractAt("DAIMock", daiAddress);
@@ -56,6 +58,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     controller = ctrl;
     setDAOAddress = sda;
     nameService = ns;
+    runAsAvatarOnly = raao;
     await setDAOAddress("UNISWAP_ROUTER", signers[0].address);
     const exchangeHelperFactory = await ethers.getContractFactory(
       "ExchangeHelper"
@@ -1128,4 +1131,36 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     expect(await goodDollar.isMinter(goodReserve.address)).to.be.false;
     expect(await goodDollar.isMinter(avatar)).to.be.true;
   });
+
+  it("should set reserve ratio daily expansion by avatar", async () => {
+    let currentReserveRatioDailyExpansion =
+      await marketMaker.reserveRatioDailyExpansion();
+    console.log(currentReserveRatioDailyExpansion.toString());
+
+    await runAsAvatarOnly(
+      goodReserve,
+      "setReserveRatioDailyExpansion(uint256,uint256)", 
+      1, 
+      1e15
+    );
+
+    let newReserveRatioDailyExpansion =
+      await marketMaker.reserveRatioDailyExpansion();
+    console.log(newReserveRatioDailyExpansion.toString());
+    
+    expect(newReserveRatioDailyExpansion).to.not.equal(currentReserveRatioDailyExpansion);
+    expect(newReserveRatioDailyExpansion).to.be.equal(BN.from("1000000000000"));
+
+    const encodedCall = goodReserve.interface.encodeFunctionData(
+      "setReserveRatioDailyExpansion", 
+      [BN.from(currentReserveRatioDailyExpansion).div(1e12),
+      1e15]
+    );
+    const ctrl = await ethers.getContractAt(
+      "Controller",
+      controller,
+      schemeMock
+    );
+    await ctrl.genericCall(goodReserve.address, encodedCall, avatar, 0);
+  });
 });

package/test/staking/CompoundStakingFactory.test.ts

@@ -4,6 +4,7 @@ import { expect } from "chai";
 import {
   CERC20,
   GoodCompoundStaking,
+  GoodCompoundStakingV2,
   CompoundStakingFactory
 } from "../../types";
 import { createDAO, deployUniswap } from "../helpers";
@@ -106,4 +107,34 @@ describe("CompoundStakingFactory", () => {
     expect(await staking.name()).to.equal("GoodCompoundStakingV2 Compound DAI");
     expect(await staking.symbol()).to.equal("gcDAI");
   });
+
+  it("should get correct gas cost settings", async () => {
+    const goodCompoundStakingV2 = (await ethers.getContractAt(
+      "GoodCompoundStakingV2",
+      await stakingFactory.impl()
+    )) as GoodCompoundStakingV2;
+
+    await goodCompoundStakingV2.init(
+      dai,
+      cdai,
+      dao.nameService.address,
+      "DAI",
+      "DAI",
+      5760,
+      stakingFactory.address,
+      compUsdOracle.address,
+      []
+    );
+
+    const INITIAL_COLLECT_INTEREST_GAS_COST = 250000;
+    const INITIAL_COLLECT_COMP_GAS_COST = 150000;
+    const gasCostForInterestTransfer = await goodCompoundStakingV2.getGasCostForInterestTransfer();
+    expect(gasCostForInterestTransfer).to.equal(INITIAL_COLLECT_INTEREST_GAS_COST);
+
+    const settings = await goodCompoundStakingV2.getSettings();
+    const collectInteresetGasCost = settings[0];
+    const compCollectGasCost = settings[1];
+    expect(collectInteresetGasCost).to.equal(INITIAL_COLLECT_INTEREST_GAS_COST);
+    expect(compCollectGasCost).to.equal(INITIAL_COLLECT_COMP_GAS_COST);
+    });
 });

package/test/staking/DonationsStaking.test.ts

@@ -235,7 +235,7 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
       "no stakingToken to stake"
     );
   });
-
+  
   it("it should stake donations with ETH according to 0.3% of pool", async () => {
     let stakeAmount = ethers.utils.parseEther("20");
     const pairContract = await ethers.getContractAt(
@@ -315,6 +315,82 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
 
     expect(totalStakedAfterEnd).to.be.equal(0);
   });
+  
+  it("should not allow to stake donations when not active", async () => {
+    let isActive = await donationsStaking.active();
+    expect(isActive).to.be.equal(true);
+    let stakeAmount = ethers.utils.parseEther("10");
+    await dai["mint(address,uint256)"](donationsStaking.address, stakeAmount);
+    
+    expect(donationsStaking.stakeDonations()).to.not.be.reverted;
+    
+    let encodedData = donationsStaking.interface.encodeFunctionData(
+      "setActive",
+      [false]
+    );
+    await genericCall(donationsStaking.address, encodedData);
+
+    isActive = await donationsStaking.active();
+    expect(isActive).to.be.equal(false);
+    await dai["mint(address,uint256)"](donationsStaking.address, stakeAmount);
+    await expect(donationsStaking.stakeDonations()).to.be.reverted;
+    // revent to original state
+    encodedData = donationsStaking.interface.encodeFunctionData(
+      "setActive",
+      [true]
+    );
+    await genericCall(donationsStaking.address, encodedData);
+  });
+
+  it("should not allow to set swap path on invalid path", async () => {
+    //Valid scenario check: from ETH to staking token
+    let pathToSet = [NULL_ADDRESS, bat.address, cDAI.address, dai.address];
+    let encodedData = donationsStaking.interface.encodeFunctionData(
+      "setSwapPaths",
+      [pathToSet]
+    );
+    await genericCall(donationsStaking.address, encodedData);
+    expect(await isEthToStakingTokenPathEqualTo(pathToSet)).to.be.true;
+
+    // Invalid scenarios checks
+    const invalidPaths = [
+      [NULL_ADDRESS],             // less than minimum 2 length
+      [bat.address, dai.address], // first is not ETH null address
+      [NULL_ADDRESS, bat.address] // last is not the staking token
+    ];
+
+    for (const invalidPath of invalidPaths) {
+      encodedData = donationsStaking.interface.encodeFunctionData(
+      "setSwapPaths",
+      [invalidPath]
+      );
+      await genericCall(donationsStaking.address, encodedData);
+      expect(await isEthToStakingTokenPathEqualTo(invalidPath)).to.be.false;  
+    }
+
+    encodedData = donationsStaking.interface.encodeFunctionData(
+      "setSwapPaths",
+      [[NULL_ADDRESS, dai.address]]
+    );
+    await genericCall(donationsStaking.address, encodedData);
+  });
+  
+  async function isEthToStakingTokenPathEqualTo(path) {
+    for (let index = 0; index < path.length; index++) {
+      let expectedValue = path[index];
+      let valueAtIndex = await donationsStaking.ethToStakingTokenSwapPath(index).catch(e=>e);
+      if (expectedValue != valueAtIndex) {
+        return false;
+      }
+    }
+
+    const outOfArray = await donationsStaking.ethToStakingTokenSwapPath(path.length).catch(e=>e);
+    if (!outOfArray.message) {
+      return false;
+    }
+
+    return true;
+  }  
 
   it("it should set stakingContract when avatar call it ", async () => {
     let stakeAmount = ethers.utils.parseEther("6000"); // Max swap amount is around 5964 with current liquidity level so we should set it to higher number in order to test functionality
@@ -397,10 +473,31 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
       avatarDaiBalanceBeforeSet.add(stakingAmountBeforeSet.sub(safeAmount))
     ); // It should send leftover stakingToken to avatar after swap to ETH in safeAmount
     expect(stakingAmountBeforeSet).to.be.gt(safeAmount); // maxSafeAmount must be smaller than actualstaking amount so we can verify that we hit the limit for transaction amount at once
+  }); 
+  
+  it("should set max liquidity percentage swap when avatar", async () => {
+    const originalPercentage = await donationsStaking.maxLiquidityPercentageSwap();
+    //fail when not avatar
+    const percentageToSet = 21;
+    expect(donationsStaking.connect(staker)["setMaxLiquidityPercentageSwap(uint24)"](percentageToSet)).
+      to.be.revertedWith("only avatar can call this method");
+    //succeed when avatar
+    let encodedData = donationsStaking.interface.encodeFunctionData(
+      "setMaxLiquidityPercentageSwap",
+      [percentageToSet]
+    );
+    await genericCall(donationsStaking.address, encodedData);
+    const actualPercentage = await donationsStaking.maxLiquidityPercentageSwap();
+    expect(actualPercentage).to.be.equal(percentageToSet);
+    //revent to original state
+    encodedData = donationsStaking.interface.encodeFunctionData(
+      "setMaxLiquidityPercentageSwap",
+      [originalPercentage]
+    );
   });
 
   it("it should return version of DonationsStaking properly", async () => {
     const version = await donationsStaking.getVersion();
     expect(version).to.be.equal("2.0.0");
   });
-});
+});

package/test/staking/GoodAaveStakingFactory.test.ts

@@ -1,7 +1,7 @@
 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 { CERC20, GoodAaveStaking, GoodAaveStakingV2, AaveStakingFactory } from "../../types";
 import { createDAO, deployUniswap } from "../helpers";
 import { Contract } from "ethers";
 
@@ -122,4 +122,39 @@ describe("AaveStakingFactory", () => {
     expect(await staking.name()).to.equal("GoodAaveStakingV2 USDC");
     expect(await staking.symbol()).to.equal("gaUSDC");
   });
+
+  it("should revert implementation on invalid initialization", async () => {
+    const goodAaveStakingV2 = (await ethers.getContractAt(
+      "GoodAaveStakingV2",
+      await stakingFactory.impl()
+    )) as GoodAaveStakingV2;
+    await expect(goodAaveStakingV2.init(
+      usdc.address,
+      lendingPool.address,
+      dao.nameService.address,
+      "USDC",
+      "USDC",
+      5760,
+      stakingFactory.address,
+      incentiveController.address,
+      aaveUsdOracle.address,
+      [cdai, dai]           // violates tokenToDaiSwapPath[0] == _token (cdai != usdc)
+    )).to.be.revertedWith(
+      "invalid _tokenToDaiSwapPath"
+    );
+    await expect(goodAaveStakingV2.init(
+      usdc.address,
+      lendingPool.address,
+      dao.nameService.address,
+      "USDC",
+      "USDC",
+      5760,
+      stakingFactory.address,
+      incentiveController.address,
+      aaveUsdOracle.address,
+      [usdc.address, cdai]  // violates _tokenToDaiSwapPath[] path leading to dai
+    )).to.be.revertedWith(
+      "invalid _tokenToDaiSwapPath"
+    );
+  });
 });

package/test/staking/SimpleDAIStaking.test.ts

@@ -32,7 +32,8 @@ describe("SimpleDAISTAking - staking with cDAI mocks", () => {
     setDAOAddress,
     initializeToken,
     goodCompoundStakingFactory,
-    deployStaking;
+    deployStaking,
+    runAsAvatarOnly;
 
   before(async () => {
     [founder, staker, ...signers] = await ethers.getSigners();
@@ -55,7 +56,8 @@ describe("SimpleDAISTAking - staking with cDAI mocks", () => {
       daiAddress,
       cdaiAddress,
       reserve,
-      setReserveToken
+      setReserveToken,
+      runAsAvatarOnly: raao,
     } = await createDAO();
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     cDAI = await ethers.getContractAt("cDAIMock", cdaiAddress);
@@ -63,6 +65,7 @@ describe("SimpleDAISTAking - staking with cDAI mocks", () => {
     controller = ctrl;
     setDAOAddress = sda;
     nameService = ns;
+    runAsAvatarOnly = raao;
     initializeToken = setReserveToken;
     goodReserve = reserve as GoodReserveCDai;
 
@@ -1258,6 +1261,33 @@ describe("SimpleDAISTAking - staking with cDAI mocks", () => {
     );
   });
 
+  it("should not be able to withdraw stake when the withdrawn amount is higher than the staked amount", async () => {
+    const stakeAmount = ethers.utils.parseEther("100");
+    const higherThanStakeAmount = ethers.utils.parseEther("101");
+    await cDAI["mint(address,uint256)"](
+      staker.address,
+      stakeAmount
+    );
+    await cDAI
+      .connect(staker)
+      .approve(goodCompoundStaking.address, higherThanStakeAmount);
+
+    await goodCompoundStaking
+      .connect(staker)
+      .stake(stakeAmount, "100", true);
+
+    const tx = await goodCompoundStaking
+      .connect(staker)
+      .withdrawStake(higherThanStakeAmount, true)
+      .catch(e => e);
+
+    expect(tx.message).to.be.not.empty;
+    // revent to original state
+    await goodCompoundStaking
+      .connect(staker)
+      .withdrawStake(stakeAmount, true);
+  });
+
   it("should pause the contract", async () => {
     let encodedCall = goodCompoundStakingFactory.interface.encodeFunctionData(
       "pause",
@@ -1423,4 +1453,24 @@ describe("SimpleDAISTAking - staking with cDAI mocks", () => {
     ).catch(e => e);
     expect(simpleStaking.message).to.be.not.empty;
   });
+
+  it("should set max liquidity percentage swap when avatar", async () => {
+    goodCompoundStaking = await deployStaking();
+    const percentageBeforeSet = await goodCompoundStaking.maxLiquidityPercentageSwap();
+    const percentageToSet = 21;
+    await runAsAvatarOnly(
+      goodCompoundStaking,
+      "setMaxLiquidityPercentageSwap(uint24)",
+      percentageToSet
+    )
+    const percentageAfterSet = await goodCompoundStaking.maxLiquidityPercentageSwap();
+    expect(percentageAfterSet).to.be.equal(percentageToSet);
+    expect(percentageAfterSet).to.not.equal(percentageBeforeSet);
+  });
+
+  it("should get decimals equal to token demials", async () => {
+    goodCompoundStaking = await deployStaking();
+    expect(await goodCompoundStaking.decimals()).to.equal(await dai.decimals());
+    expect(await goodCompoundStaking.decimals()).to.equal(18);
+  });
 });

package/test/staking/StakingRewards.test.ts

@@ -614,6 +614,44 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
       .withdrawStake(stakingAmount, false);
   });
 
+  it("should get user minted and pending rewards", async () => {
+    const goodFundManagerFactory = await ethers.getContractFactory(
+      "GoodFundManager"
+    );
+    const currentBlockNumber = await ethers.provider.getBlockNumber();
+    const encodedData = goodFundManagerFactory.interface.encodeFunctionData(
+      "setStakingReward",
+      [
+        "1000",
+        goodCompoundStaking.address,
+        currentBlockNumber,
+        currentBlockNumber + 5000,
+        false
+      ] // set 10 gd per block
+    );
+    await genericCall(goodFundManager.address, encodedData, avatar, 0);
+
+    const stakingAmount = ethers.utils.parseEther("100");
+
+    await dai["mint(address,uint256)"](staker.address, stakingAmount);
+    await dai
+      .connect(staker)
+      .approve(goodCompoundStaking.address, stakingAmount);
+    await goodCompoundStaking.connect(staker).stake(stakingAmount, 0, false);
+
+    await advanceBlocks(4);
+
+    const userMintedAndPending = await goodCompoundStaking.getUserMintedAndPending(staker.address);
+    const userMintedReward = userMintedAndPending[0].toString();
+    const userPendingReward = userMintedAndPending[1].toString();
+    expect(userMintedReward).to.equal("5000");
+    expect(userPendingReward).to.equal("2000");
+  
+    await goodCompoundStaking
+      .connect(staker)
+      .withdrawStake(stakingAmount, false);
+  });
+
   it("it should get rewards with 1x multiplier for after threshold pass", async () => {
     const goodFundManagerFactory = await ethers.getContractFactory(
       "GoodFundManager"

package/test/staking/UsdcAaveStaking.test.ts

@@ -29,7 +29,10 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
     lendingPool,
     setDAOAddress,
     genericCall,
-    goodAaveStakingFactory;
+    goodAaveStakingFactory,
+    runAsAvatarOnly,
+    deployStaking;
+
   before(async () => {
     [founder, staker, ...signers] = await ethers.getSigners();
     schemeMock = signers.pop();
@@ -55,7 +58,8 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
       marketMaker: mm,
       daiAddress,
       genericCall: gc,
-      COMP
+      COMP,
+      runAsAvatarOnly: raao
     } = await createDAO();
     dai = await ethers.getContractAt("DAIMock", daiAddress);
     avatar = av;
@@ -63,6 +67,7 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
     setDAOAddress = sda;
     nameService = ns;
     genericCall = gc;
+    runAsAvatarOnly = raao;
     console.log("deployed dao", {
       founder: founder.address,
       gd,
@@ -133,23 +138,26 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
       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;
-      });
+    deployStaking = async () => {
+      return 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;
+        });
+    };
+    goodAaveStaking = await deployStaking();
     await usdc["mint(address,uint256)"](
       founder.address,
       ethers.utils.parseUnits("500000000000000", 6)
@@ -306,4 +314,22 @@ describe("UsdcAaveStakingV2 - staking with USDC mocks to AAVE interface", () =>
     await token1.transfer(pair.address, token1Amount);
     await pair.mint(founder.address);
   }
+
+  it("should set gas cost to interest collection parameters", async () => {
+    const stakingContract = await deployStaking();
+    const collectGasCostBefore = await stakingContract.collectInterestGasCost();
+    const claimStakeGasCostBefore = await stakingContract.collectInterestGasCost();
+    await runAsAvatarOnly(
+      stakingContract,
+      "setcollectInterestGasCostParams(uint32,uint32)",
+      999,
+      999
+    )
+    const collectGasCostAfter = await stakingContract.collectInterestGasCost();
+    const claimStakeGasCostAfter = await stakingContract.collectInterestGasCost();
+    expect(collectGasCostAfter).to.not.equal(collectGasCostBefore);
+    expect(collectGasCostAfter).to.equal(999);
+    expect(claimStakeGasCostAfter).to.not.equal(claimStakeGasCostBefore);
+    expect(claimStakeGasCostAfter).to.equal(999);
+  });
 });