@gooddollar/goodprotocol 2.0.25-beta.9 → 2.0.26-beta.0

package/test/governance/CompoundVotingMachine.daoscheme.ts

@@ -89,6 +89,9 @@ describe("CompoundVotingMachine#DAOScheme", () => {
     await grep.mint(acct.address, ethers.BigNumber.from("500000"));
 
     queuePeriod = await gov.queuePeriod().then(_ => _.toNumber());
+
+    //disable guardian
+    await gov.renounceGuardian()
   });
 
   ///cell 0 - votingPeriod blocks, 1 - quoromPercentage, 2 - proposalPercentage,3 - proposalMaxOperations, 4 - voting delay blocks, 5 - queuePeriod time

package/test/governance/CompoundVotingMachine.guardian.test.ts

@@ -185,13 +185,13 @@ describe("CompoundVotingMachine#Guardian", () => {
 
     await gov
       .connect(signers[4])
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        targets,
-        values,
-        signatures,
-        callDatas,
-        "do nothing"
-      );
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "do nothing"
+    );
     let proposalId = await gov.latestProposalIds(signers[4].address);
     await advanceBlocks(1);
 
@@ -204,34 +204,89 @@ describe("CompoundVotingMachine#Guardian", () => {
     await grep.delegateTo(root.address); //delegate back our votes
   });
 
+  it("Should not be able to pass proposal without guardian approval", async () => {
+    let targets = [gov.address];
+    let values = ["0"];
+    let signatures = ["setGuardian(address)"];
+    let callDatas = [encodeParameters(["address"], [signers[1].address])];
+
+    await gov
+      .connect(root)
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "set guardian"
+    );
+    let proposalBlock = +(await ethers.provider.getBlockNumber());
+    let proposalId = await gov.latestProposalIds(root.address);
+    await advanceBlocks(1);
+    await gov.connect(root).castVote(proposalId, true);
+    await increaseTime(queuePeriod);
+    expect(states[await gov.state(proposalId)]).to.equal("Succeeded");
+
+    await expect(gov.execute(proposalId)).revertedWith(/not approved/);
+
+  })
+
   it("Should be able to pass proposal to change guardian", async () => {
-    console.log(
-      grep.address,
-      await grep.totalSupply().then(_ => _.toString()),
-      await (await grep.getVotes(root.address)).toString(),
-      await (await grep.balanceOfLocal(root.address)).toString(),
-      await gov.rep()
+    let targets = [gov.address];
+    let values = ["0"];
+    let signatures = ["setGuardian(address)"];
+    let callDatas = [encodeParameters(["address"], [signers[2].address])];
+
+    await gov
+      .connect(root)
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "set guardian"
     );
+    let proposalBlock = +(await ethers.provider.getBlockNumber());
+    let proposalId = await gov.latestProposalIds(root.address);
+    await advanceBlocks(1);
+    await gov.connect(root).castVote(proposalId, true);
+    await increaseTime(queuePeriod);
+    expect(states[await gov.state(proposalId)]).to.equal("Succeeded");
+
+    await gov.connect(signers[1]).approveProposal(proposalId)
+
+    await gov.execute(proposalId);
+    expect(states[await gov.state(proposalId)]).to.equal("Executed");
+
+    //acct should now have 1M after proposal minted rep
+    expect(await gov.guardian()).to.equal(signers[2].address);
+  });
+
+  it("Should be able to pass proposal without approval if no guardian set", async () => {
     let targets = [gov.address];
     let values = ["0"];
     let signatures = ["setGuardian(address)"];
     let callDatas = [encodeParameters(["address"], [signers[1].address])];
 
+    await gov.connect(signers[2]).renounceGuardian()
+
+    expect(await gov.guardian()).equal(ethers.constants.AddressZero)
+
     await gov
       .connect(root)
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        targets,
-        values,
-        signatures,
-        callDatas,
-        "set guardian"
-      );
-    let proposalBlock = +(await ethers.provider.getBlockNumber());
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "set guardian"
+    );
+
     let proposalId = await gov.latestProposalIds(root.address);
     await advanceBlocks(1);
     await gov.connect(root).castVote(proposalId, true);
     await increaseTime(queuePeriod);
     expect(states[await gov.state(proposalId)]).to.equal("Succeeded");
+
     await gov.execute(proposalId);
     expect(states[await gov.state(proposalId)]).to.equal("Executed");
 

package/test/governance/CompoundVotingMachine.state.test.ts

@@ -107,6 +107,9 @@ describe("CompoundVotingMachine#States", () => {
     votePeriod = await gov.votingPeriod().then(_ => _.toNumber());
     queuePeriod = await gov.queuePeriod().then(_ => _.toNumber());
     gracePeriod = await gov.gracePeriod().then(_ => _.toNumber());
+
+    //disable guardian
+    await gov.renounceGuardian()
   });
 
   it("Invalid for proposal not found", async () => {
@@ -130,13 +133,13 @@ describe("CompoundVotingMachine#States", () => {
     await grep.delegateTo(actor.address);
     await gov
       .connect(actor)
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        targets,
-        values,
-        signatures,
-        callDatas,
-        "do nothing"
-      );
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "do nothing"
+    );
     let newProposalId = await gov.proposalCount();
 
     // send away the delegates
@@ -212,13 +215,13 @@ describe("CompoundVotingMachine#States", () => {
     await advanceBlocks(1);
     await gov
       .connect(actor)
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        targets,
-        values,
-        signatures,
-        callDatas,
-        "do nothing"
-      );
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "do nothing"
+    );
     let proposalId = await gov.latestProposalIds(actor.address);
     await advanceBlocks(1);
     await gov.connect(actor).castVote(proposalId, false);
@@ -237,13 +240,13 @@ describe("CompoundVotingMachine#States", () => {
     await advanceBlocks(1);
     await gov
       .connect(actor)
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        targets,
-        values,
-        signatures,
-        callDatas,
-        "do nothing"
-      );
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "do nothing"
+    );
     let proposalId = await gov.latestProposalIds(actor.address);
     await advanceBlocks(1);
     await gov.connect(actor).castVote(proposalId, true);
@@ -310,13 +313,13 @@ describe("CompoundVotingMachine#States", () => {
     await advanceBlocks(1);
     await gov
       .connect(signers[0])
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        targets,
-        values,
-        signatures,
-        callDatas,
-        "do nothing"
-      );
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "do nothing"
+    );
     let proposalId = await gov.proposalCount();
     await advanceBlocks(1);
 

package/test/governance/StakersDistribution.test.ts

@@ -652,7 +652,6 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
     );
     await advanceBlocks(4);
     const gdaoBalanceBeforeWithdraw = await grep.balanceOf(staker.address);
-    console.log({ gdaoBalanceBeforeWithdraw, rewardsPerBlock });
     await simpleStaking1.connect(staker).withdrawStake(stakingAmount, false);
     const withdrawBlockNumber = await ethers.provider.getBlockNumber();
     await stakersDistribution.claimReputation(staker.address, [
@@ -903,8 +902,8 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
         staker.address,
         simpleStaking1.address
       );
-    expect(userMintedRewardAfterStake.eq(0));
-    expect(userPendingRewardAfterStake.gt(0));
+    expect(userMintedRewardAfterStake).eq(0);
+    expect(userPendingRewardAfterStake).gt(0);
 
     await stakersDistribution.claimReputation(staker.address, [
       simpleStaking1.address
@@ -915,8 +914,8 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
         staker.address,
         simpleStaking1.address
       );
-    expect(userMintedRewardAfterClaim.gt(0));
-    expect(userPendingRewardAfterClaim.eq(0));
+    expect(userMintedRewardAfterClaim).gt(0);
+    expect(userPendingRewardAfterClaim).eq(0);
   });
 
   async function getUserMintedAndPendingRewards(
@@ -933,4 +932,79 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
 
     return [userMintedReward, userPendingReward];
   }
+
+  it("should update user rewards when monthly rate has changed", async () => {
+    const goodFundManagerFactory = await ethers.getContractFactory(
+      "GoodFundManager"
+    );
+
+    const simpleStaking1 = await deployDaiStaking();
+    const ictrl = await ethers.getContractAt(
+      "Controller",
+      controller,
+      schemeMock
+    );
+    const currentBlockNumber = await ethers.provider.getBlockNumber();
+    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
+      "setStakingReward",
+      [
+        "100000",
+        simpleStaking1.address,
+        currentBlockNumber - 5,
+        currentBlockNumber + 20,
+        false
+      ] // set 10 gd per block
+    );
+
+    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
+
+    let [userMintedRewardBeforeStake, userPendingRewardBeforeStake] =
+      await getUserMintedAndPendingRewards(
+        staker.address,
+        simpleStaking1.address
+      );
+    expect(userMintedRewardBeforeStake).to.eq("0");
+    expect(userPendingRewardBeforeStake).to.eq("0");
+
+    const stakingAmount = ethers.utils.parseEther("1000");
+    await dai["mint(address,uint256)"](staker.address, stakingAmount);
+    await dai.connect(staker).approve(simpleStaking1.address, stakingAmount);
+    await simpleStaking1.connect(staker).stake(stakingAmount, 0, false);
+    await advanceBlocks(5); //should accumulate some gdao rewards
+
+    const rewardsPerBlockBefore = await stakersDistribution.rewardsPerBlock(
+      simpleStaking1.address
+    );
+
+    // reduce rewarsd speed by half from 2m to 1m
+    let encoded = stakersDistribution.interface.encodeFunctionData(
+      "setMonthlyReputationDistribution",
+      [ethers.utils.parseEther("1000000")]
+    );
+    await genericCall(stakersDistribution.address, encoded);
+    const rewardsPerBlockAfter = await stakersDistribution.rewardsPerBlock(
+      simpleStaking1.address
+    );
+    let [userMintedRewardAfterStake, userPendingRewardAfterStake] =
+      await getUserMintedAndPendingRewards(
+        staker.address,
+        simpleStaking1.address
+      );
+    expect(userMintedRewardAfterStake).eq(0);
+    expect(userPendingRewardAfterStake).gt(0);
+
+    await advanceBlocks(4); //should accumulate some gdao rewards
+    let [userMintedRewardAfterUpdate, userPendingRewardAfterUpdate] =
+      await getUserMintedAndPendingRewards(
+        staker.address,
+        simpleStaking1.address
+      );
+    expect(userMintedRewardAfterUpdate).eq(0);
+    // rewards speed has been reduced by half,
+    expect(rewardsPerBlockAfter).lt(rewardsPerBlockBefore.mul(55).div(100));
+    // was forced 4 blocks to pass since reward update
+    expect(userPendingRewardAfterUpdate).eq(
+      userPendingRewardAfterStake.add(rewardsPerBlockAfter.mul(4))
+    );
+  });
 });

package/test/helpers.ts

@@ -301,6 +301,9 @@ export const createDAO = async (tokenType: "super" | "regular" = "super") => {
       kind: "uups"
     }
   );
+
+  console.log("deploying disthelper...");
+
   let distHelper = await upgrades.deployProxy(
     await ethers.getContractFactory("DistributionHelper"),
     [nameService.address],
@@ -438,6 +441,10 @@ export const createDAO = async (tokenType: "super" | "regular" = "super") => {
   await setDAOAddress("REPUTATION", reputation.address);
 
   console.log("setting reserve token...");
+  await cDAI["mint(address,uint256)"](
+    goodReserve.address,
+    10000
+  );
   await setReserveToken(
     cDAI.address,
     "100", //1gd

package/test/reserve/DistributionHelper.test.ts

@@ -195,7 +195,7 @@ describe("DistributionHelper", () => {
     expect(dr.transferType).to.equal(2);
   });
 
-  it("should distribute via fuse bridge", async () => {
+  it("should not distribute via fuse bridge", async () => {
     const { distHelper, bridge } = await loadFixture(fixture);
 
     const recipient = signers[0];
@@ -215,15 +215,15 @@ describe("DistributionHelper", () => {
     await genericCall(distHelper.address, encodedCall, avatar.address, 0);
 
     await goodDollar.mint(distHelper.address, "100000000000");
-    await distHelper.onDistribution("100000000000");
-    expect(await goodDollar.balanceOf(bridge.address)).to.equal(
-      (100000000000 * 2000) / 10000
-    );
-
-    const events = await bridge.queryFilter(bridge.filters.OnToken());
-    expect(events[0].args.sender).to.equal(distHelper.address);
-    expect(events[0].args.amount).to.equal((100000000000 * 2000) / 10000);
-    expect(events[0].args.data).to.equal(recipient.address.toLowerCase());
+    await expect(distHelper.onDistribution("100000000000")).revertedWith("DEPRECATED");
+    // expect(await goodDollar.balanceOf(bridge.address)).to.equal(
+    //   (100000000000 * 2000) / 10000
+    // );
+
+    // const events = await bridge.queryFilter(bridge.filters.OnToken());
+    // expect(events[0].args.sender).to.equal(distHelper.address);
+    // expect(events[0].args.amount).to.equal((100000000000 * 2000) / 10000);
+    // expect(events[0].args.data).to.equal(recipient.address.toLowerCase());
   });
 
   it("should distribute via layerzero bridge", async () => {

package/test/reserve/GoodMarketMaker.test.ts

@@ -120,6 +120,22 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
     expect(onecDAIReturn.toNumber() / 100).to.be.equal(10000); //0.0001 cdai is 1 gd, so for 1eth you get 10000 gd (divide by 100 to account for 2 decimals precision)
   });
 
+  it("should calculate mint UBI correctly for 8 decimals precision when price is 0.0001 and 100% ratio", async () => {
+    const expansion = await initializeToken(
+      cdai,
+      "100", //1gd
+      "10000", //0.0001 cDai
+      "1000000" //100% rr
+    );
+    const gdPrice = await marketMaker.currentPrice(cdai);
+    const toMint = await marketMaker.calculateMintInterest(cdai, "100000000");
+    const expectedTotalMinted = 10 ** 8 / gdPrice.toNumber(); //1cdai divided by gd price;
+    expect(expectedTotalMinted).to.be.equal(10000); //1k GD since price is 0.0001 cdai for 1 gd
+    expect(toMint.toString()).to.be.equal(
+      (expectedTotalMinted * 100).toString()
+    ); //add 2 decimals precision
+  });
+
   it("should update reserve ratio by days passed", async () => {
     const expansion = await marketMaker.reserveRatioDailyExpansion();
     // 20% yearly. set up in the constructor
@@ -144,16 +160,6 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
     ).to.be.equal("994511"); // 998777 * 0.999388834642296000000000000^7
   });
 
-  it("should calculate mint UBI correctly for 8 decimals precision", async () => {
-    const gdPrice = await marketMaker.currentPrice(cdai);
-    const toMint = await marketMaker.calculateMintInterest(cdai, "100000000");
-    const expectedTotalMinted = 10 ** 8 / gdPrice.toNumber(); //1cdai divided by gd price;
-    expect(expectedTotalMinted).to.be.equal(10000); //1k GD since price is 0.0001 cdai for 1 gd
-    expect(toMint.toString()).to.be.equal(
-      (expectedTotalMinted * 100).toString()
-    ); //add 2 decimals precision
-  });
-
   it("should not return a sell contribution if the given gd is less than the given contribution amount", async () => {
     let dai = await deployDAIMock();
 
@@ -181,13 +187,27 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
   });
 
   it("should be able to calculate and update bonding curve gd balance based on oncoming cDAI and the price stays the same", async () => {
-    const priceBefore = await marketMaker.currentPrice(cdai);
+    let priceBefore = await marketMaker.currentPrice(cdai);
     await marketMaker.mintInterest(cdai, BN.from(1e8));
+    let priceAfter = await marketMaker.currentPrice(cdai)
+
+    expect(priceAfter).gt(0)
+    expect(priceBefore).gt(0)
     expect(
       Math.floor(
-        (await marketMaker.currentPrice(cdai).then(_ => _.toNumber())) / 100
-      ).toString()
+        (priceAfter.toNumber() / 100)).toString()
     ).to.be.equal(Math.floor(priceBefore.toNumber() / 100).toString());
+
+
+    // very large amount of cdai
+    priceBefore = await marketMaker.currentPrice(cdai);
+    await marketMaker.mintInterest(cdai, ethers.utils.parseEther("1"));
+    priceAfter = await marketMaker.currentPrice(cdai)
+
+    console.log({ priceAfter, priceBefore })
+    expect(priceAfter).gt(0)
+    expect(priceBefore).gt(0)
+    expect(priceAfter).to.eq(priceBefore);
   });
 
   it("should not be able to mint interest by a non owner", async () => {
@@ -273,11 +293,12 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       "800000" //80% rr
     );
     const price = await marketMaker.currentPrice(dai);
-    expect(price.toString()).to.be.equal("100000000000000"); //1gd is equal 0.0001 dai = 1000000000000000 wei;
+    expect(price.toString()).to.be.equal(ethers.utils.parseEther("0.000125")); //1gd is equal 0.0001/1*0.8 = 0.000125
     const oneDAIReturn = await marketMaker.buyReturn(
       dai,
       ethers.utils.parseEther("1") //1Dai
     );
+
     //bancor formula to calcualte return
     //gd return = gdsupply * ((1+tokenamount/tokensupply)^rr -1)
     const expectedReturn = 1 * ((1 + 1 / 0.0001) ** 0.8 - 1);
@@ -292,16 +313,27 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       dai,
       ethers.utils.parseEther("1")
     );
-    const expectedTotalMinted = 10 ** 18 / gdPrice.toNumber();
-    // according to the sell formula the gd price should be 10^14 so 10^18 / 10^14 = 10^4
-    // Return = _reserveBalance * (1 - (1 - _sellAmount / _supply) ^ (1000000 / _reserveRatio))
-    expect(expectedTotalMinted).to.be.equal(10000);
+    let reserveToken = await marketMaker.reserveTokens(dai);
+
+    //we expect price to stay the same p = reserve/supply*RR
+    const newPrice = reserveToken.reserveSupply.add(ethers.utils.parseEther("1")).mul(1e8).div(reserveToken.gdSupply.add(toMint).mul(reserveToken.reserveRatio))
+    expect(newPrice).equal(gdPrice)
+
+    // the formula is amountToMint = reserveInterest * tokenSupply / reserveBalance
+    const expectedTotalMinted = 10 ** 18 * reserveToken.gdSupply.toNumber() / reserveToken.reserveSupply.toNumber()
+    expect(expectedTotalMinted).to.be.equal(1000000);
     expect(toMint.toString()).to.be.equal(
-      (expectedTotalMinted * 100).toString()
+      (expectedTotalMinted).toString()
     );
   });
 
   it("should calculate sell return with cDAI", async () => {
+    await initializeToken(
+      cdai,
+      "1000000000", //1gd
+      "100000000000", //0.0001 cDai
+      "900000" //80% rr
+    );
     const gDReturn = await marketMaker.sellReturn(
       cdai,
       10 //0.1 gd
@@ -515,19 +547,36 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
   });
 
   it("should calculate amount of gd to mint based on incoming cDAI without effecting bonding curve price", async () => {
-    const priceBefore = await marketMaker.currentPrice(dai);
-    const toMint = await marketMaker.calculateMintInterest(
+    await initializeToken(
       dai,
-      BN.from("1000000000000000000")
-    );
-    const totalMinted = 1e18 / priceBefore.toNumber();
-    expect(toMint.toString()).to.be.equal(
-      Math.floor(totalMinted * 100).toString()
+      6e11,
+      ethers.utils.parseEther("600000"),
+      5e5
     );
+
+    const priceBefore = await marketMaker.currentPrice(dai);
+
+    await marketMaker.mintInterest(dai, ethers.utils.parseEther("100"))
     const priceAfter = await marketMaker.currentPrice(dai);
     expect(priceBefore.toString()).to.be.equal(priceAfter.toString());
   });
 
+  it("should calculate amount of gd to mint based on incoming cDAI with small precision issue effecting bonding curve price in very low amounts", async () => {
+    await initializeToken(
+      dai,
+      600,
+      600000000,
+      5e5
+    );
+
+    const priceBefore = await marketMaker.currentPrice(dai);
+
+    await marketMaker.mintInterest(dai, 60000)
+    const priceAfter = await marketMaker.currentPrice(dai);
+    expect(priceBefore).equal(200000000)
+    expect(priceAfter).equal(200020000)
+  });
+
   it("should not change the reserve ratio when calculate how much decrease it for the reservetoken", async () => {
     let reserveTokenBefore = await marketMaker.reserveTokens(cdai);
     let reserveRatioBefore = reserveTokenBefore.reserveRatio;