@gooddollar/goodprotocol 1.0.13-beta.0 → 1.0.13

package/test/helpers.ts

@@ -225,7 +225,7 @@ export const createDAO = async () => {
   const setReserveToken = async (token, gdReserve, tokenReserve, RR) => {
     const encoded = marketMaker.interface.encodeFunctionData(
       "initializeToken",
-      [token, gdReserve, tokenReserve, RR]
+      [token, gdReserve, tokenReserve, RR, 0]
     );
 
     await ictrl.genericCall(marketMaker.address, encoded, Avatar.address, 0);

package/test/reserve/GoodMarketMaker.test.ts

@@ -55,7 +55,7 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       marketMaker: mm,
       setSchemes,
       setReserveToken,
-      setDAOAddress,
+      setDAOAddress
     } = await createDAO();
     avatar = av;
     marketMaker = mm.connect(fakeReserve);
@@ -144,7 +144,7 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
     expect(
       await marketMaker
         .reserveTokens(cdai)
-        .then((_) => _["reserveRatio"].toString())
+        .then(_ => _["reserveRatio"].toString())
     ).to.be.equal("994511"); // 998777 * 0.999388834642296000000000000^7
   });
 
@@ -165,13 +165,14 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
     const marketMaker1 = await upgrades.deployProxy(MM, [
       await marketMaker.nameService(),
       999388834642296,
-      1e15,
+      1e15
     ]);
     await marketMaker1.initializeToken(
       dai,
       "100", //1gd
       ethers.utils.parseEther("0.0001"),
-      "800000" //80% rr
+      "800000", //80% rr,
+      0
     );
     const res = marketMaker1.sellWithContribution(
       dai,
@@ -188,7 +189,7 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
     await marketMaker.mintInterest(cdai, BN.from(1e8));
     expect(
       Math.floor(
-        (await marketMaker.currentPrice(cdai).then((_) => _.toNumber())) / 100
+        (await marketMaker.currentPrice(cdai).then(_ => _.toNumber())) / 100
       ).toString()
     ).to.be.equal(Math.floor(priceBefore.toNumber() / 100).toString());
   });

package/test/staking/DonationsStaking.test.ts

@@ -218,6 +218,7 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
     expect(totalStakedBeforeStake).to.be.equal(0);
     expect(totalStakedAfterStake).to.be.gt(totalStakedBeforeStake);
   });
+
   it("it should stake donations with DAI", async () => {
     let stakeAmount = ethers.utils.parseEther("10");
     await dai["mint(address,uint256)"](donationsStaking.address, stakeAmount);
@@ -228,6 +229,13 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
       stakeAmount
     );
   });
+
+  it("it should reverted when there is no token to stake", async () => {
+    await expect(donationsStaking.stakeDonations()).to.be.revertedWith(
+      "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(
@@ -263,6 +271,7 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
     expect(stakeAmount).to.be.gt(maxAmount);
     expect(stakeAmount.sub(maxAmount)).to.be.equal(ethBalanceAfterStake); // check leftover ETH in contract
   });
+
   it("withdraw should reverted if caller not avatar", async () => {
     const tx = await donationsStaking
       .connect(staker)
@@ -270,6 +279,7 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
       .catch(e => e);
     expect(tx.message).to.have.string("only avatar can call this method");
   });
+
   it("it should withdraw donationStaking when caller is avatar and return funds to avatar", async () => {
     const totalStakedBeforeEnd = await donationsStaking.totalStaked();
     const avatarDaiBalanceBeforeEnd = await dai.balanceOf(avatar);
@@ -305,16 +315,9 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
 
     expect(totalStakedAfterEnd).to.be.equal(0);
   });
+
   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
-    const donationsStakingFactory = await ethers.getContractFactory(
-      "DonationsStaking",
-      {
-        libraries: {
-          UniswapV2SwapHelper: swapHelper.address
-        }
-      }
-    );
 
     await dai["mint(address,uint256)"](donationsStaking.address, stakeAmount);
     await donationsStaking.stakeDonations();
@@ -342,7 +345,7 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
       .then(async contract => {
         await contract.init(
           bat.address,
-          cDAI.address,
+          cBat.address,
           nameService.address,
           "Good BAT",
           "gBAT",
@@ -353,16 +356,21 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
         );
         return contract;
       });
-    //let encodedData = donationsStakingFactory.interface.encodeFunctionData(
-    //  "setStakingContract",
-    //  [simpleStaking.address, [NULL_ADDRESS, bat.address]]
-    //);
-    //
-    //await genericCall(donationsStaking.address, encodedData);
-    await donationsStaking.setStakingContract(simpleStaking.address, [
-      NULL_ADDRESS,
-      bat.address
-    ]);
+
+    //not avatar
+    await expect(
+      donationsStaking.setStakingContract(simpleStaking.address, [
+        NULL_ADDRESS,
+        bat.address
+      ])
+    ).to.be.reverted;
+
+    let encodedData = donationsStaking.interface.encodeFunctionData(
+      "setStakingContract",
+      [simpleStaking.address, [NULL_ADDRESS, bat.address]]
+    );
+    await genericCall(donationsStaking.address, encodedData);
+
     const avatarDaiBalanceAfterSet = await dai.balanceOf(avatar);
     const stakingAmountAfterSet = await goodCompoundStaking.balanceOf(
       donationsStaking.address
@@ -390,4 +398,9 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
     ); // 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("it should return version of DonationsStaking properly", async () => {
+    const version = await donationsStaking.getVersion();
+    expect(version).to.be.equal("2.0.0");
+  });
 });

package/test/ubi/UBIScheme.e2e.test.ts

@@ -226,7 +226,7 @@ describe("UBIScheme - network e2e tests", () => {
   it("should award a new user with the award amount on first time execute claim", async () => {
     await increaseTime(86400);
     let claimerBalance1 = await goodDollar.balanceOf(claimer.address);
-    let ce = await ubi.connect(claimer).checkEntitlement();
+    let ce = await ubi.connect(claimer)["checkEntitlement()"]();
     await ubi.connect(claimer).claim();
     let claimerBalance2 = await goodDollar.balanceOf(claimer.address);
     expect(claimerBalance2.sub(claimerBalance1).toNumber()).to.be.equal(

package/test/ubi/UBIScheme.test.ts

@@ -281,7 +281,7 @@ describe("UBIScheme", () => {
   });
 
   it("should return the reward value for entitlement user", async () => {
-    let amount = await ubi.connect(claimer4).checkEntitlement();
+    let amount = await ubi.connect(claimer4)["checkEntitlement()"]();
     let claimAmount = await firstClaimPool.claimAmount();
     expect(amount.toString()).to.be.equal(claimAmount.toString());
   });
@@ -324,13 +324,13 @@ describe("UBIScheme", () => {
   it("should return the daily ubi for entitlement user", async () => {
     // claimer3 hasn't claimed during that interval so that user
     // may have the dailyUbi
-    let amount = await ubi.connect(claimer3).checkEntitlement();
+    let amount = await ubi.connect(claimer3)["checkEntitlement()"]();
     let dailyUbi = await ubi.dailyUbi();
     expect(amount.toString()).to.be.equal(dailyUbi.toString());
   });
   it("should return 0 for entitlement if the user has already claimed for today", async () => {
     await ubi.connect(claimer4).claim();
-    let amount = await ubi.connect(claimer4).checkEntitlement();
+    let amount = await ubi.connect(claimer4)["checkEntitlement()"]();
     expect(amount.toString()).to.be.equal("0");
   });
 
@@ -548,7 +548,7 @@ describe("UBIScheme", () => {
     await increaseTime(ONE_DAY);
     await ubi.connect(claimer1).claim();
     await increaseTime(ONE_DAY);
-    let amount = await ubi.connect(claimer1).checkEntitlement();
+    let amount = await ubi.connect(claimer1)["checkEntitlement()"]();
     let balance2 = await goodDollar.balanceOf(ubi.address);
     let estimated = await ubi.estimateNextDailyUBI();
     expect(amount).to.be.equal(estimated);

package/test/utils/ProxyFactory.test.ts

@@ -99,4 +99,35 @@ describe("proxyfactory", () => {
     proxy = await ethers.getContractAt("UpgradableMock", proxyAddr);
     expect(await proxy.owner()).to.eq(signers[2].address);
   });
+
+  it("should not be able to re-initialize proxy", async () => {
+    const c1 = await (
+      await ethers.getContractFactory("UpgradableMock")
+    ).deploy();
+    const encoded = c1.interface.encodeFunctionData("initialize", [
+      signers[2].address
+    ]);
+
+    const deployTX = await (
+      await factory.deployProxy(4, c1.address, encoded)
+    ).wait();
+    const proxyAddr = deployTX.events.find(_ => _.event === "ProxyCreated").args
+      .proxy;
+    let proxy = await ethers.getContractAt("ERC1967Proxy", proxyAddr);
+
+    const c2 = await (
+      await ethers.getContractFactory("UpgradableMock")
+    ).deploy();
+
+    const encoded2 = c1.interface.encodeFunctionData("initialize", [
+      signers[3].address
+    ]);
+
+    await expect(
+      proxy["initialize(address,bytes)"](c2.address, encoded)
+    ).revertedWith("initialized");
+
+    let orgproxy = await ethers.getContractAt("UpgradableMock", proxyAddr);
+    expect(await orgproxy.owner()).to.eq(signers[2].address);
+  });
 });