@gooddollar/goodprotocol 1.0.13-beta.1 → 1.0.14

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

@@ -357,10 +357,20 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
         return contract;
       });
 
-    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

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