@gooddollar/goodprotocol 1.0.28 → 1.0.29-beta.1

package/test/reserve/GoodReserveCDai.distribution.test.ts

@@ -0,0 +1,296 @@
+import { ethers, waffle } from "hardhat";
+import { expect } from "chai";
+import { GoodReserveCDai, DistributionHelper } from "../../types";
+import { createDAO, increaseTime } from "../helpers";
+import { Contract } from "ethers";
+import { FormatTypes } from "@ethersproject/abi";
+
+const BN = ethers.BigNumber;
+export const NULL_ADDRESS = ethers.constants.AddressZero;
+export const BLOCK_INTERVAL = 1;
+
+describe("GoodReserve - Distribution Helper", () => {
+  let goodReserve: GoodReserveCDai;
+  let goodDollar: Contract,
+    genericCall,
+    avatar,
+    founder,
+    signers,
+    setDAOAddress,
+    nameService,
+    cDai;
+
+  before(async () => {
+    [founder, ...signers] = await ethers.getSigners();
+
+    let {
+      controller: ctrl,
+      avatar: av,
+      gd,
+      identity,
+      setDAOAddress: sda,
+      setSchemes,
+      reserve,
+      cdaiAddress,
+      genericCall: gc,
+      nameService: ns
+    } = await createDAO();
+
+    nameService = ns;
+    genericCall = gc;
+    cDai = cdaiAddress;
+    avatar = av;
+    setDAOAddress = sda;
+
+    console.log("deployed dao", {
+      founder: founder.address,
+      gd,
+      identity,
+      avatar
+    });
+
+    goodDollar = await ethers.getContractAt("IGoodDollar", gd);
+
+    console.log("deployed contribution, deploying reserve...", {
+      founder: founder.address
+    });
+
+    goodReserve = reserve as GoodReserveCDai;
+
+    console.log("setting permissions...");
+  });
+
+  const fixture = async (wallets, provider) => {
+    const df = await ethers.getContractFactory("DistributionHelper");
+    wallets = provider.getWallets();
+    const distHelper = (await waffle.deployContract(wallets[0], {
+      abi: JSON.parse(df.interface.format(FormatTypes.json) as string) as any[],
+      bytecode: df.bytecode
+    })) as DistributionHelper;
+
+    return { distHelper };
+  };
+
+  const deployed_fixture = async (wallets, provider) => {
+    const df = await ethers.getContractFactory("DistributionHelper");
+    wallets = provider.getWallets();
+    const distHelper = (await waffle.deployContract(wallets[0], {
+      abi: JSON.parse(df.interface.format(FormatTypes.json) as string) as any[],
+      bytecode: df.bytecode
+    })) as DistributionHelper;
+
+    await distHelper.initialize(nameService.address);
+
+    const encodedCall = goodReserve.interface.encodeFunctionData(
+      "setDistributionHelper",
+      [distHelper.address, 1000]
+    );
+
+    await genericCall(goodReserve.address, encodedCall, avatar.address, 0);
+
+    return { distHelper };
+  };
+
+  const deployed_revert_fixture = async (wallets, provider) => {
+    const df = await ethers.getContractFactory("DistributionHelperTest");
+    wallets = provider.getWallets();
+    const distHelper = (await waffle.deployContract(wallets[0], {
+      abi: JSON.parse(df.interface.format(FormatTypes.json) as string) as any[],
+      bytecode: df.bytecode
+    })) as DistributionHelper;
+
+    await distHelper.initialize(nameService.address);
+
+    const encodedCall = goodReserve.interface.encodeFunctionData(
+      "setDistributionHelper",
+      [distHelper.address, 1000]
+    );
+
+    await genericCall(goodReserve.address, encodedCall, avatar.address, 0);
+
+    return { distHelper };
+  };
+
+  it("should allow avatar to set distribution helper target", async () => {
+    const { distHelper } = await waffle.loadFixture(fixture);
+    const encodedCall = goodReserve.interface.encodeFunctionData(
+      "setDistributionHelper",
+      [distHelper.address, 1000]
+    );
+
+    await genericCall(goodReserve.address, encodedCall, avatar.address, 0);
+
+    expect(await goodReserve.distributionHelper()).to.equal(distHelper.address);
+    expect(await goodReserve.nonUbiBps()).to.equal(1000);
+  });
+
+  it("should not allow to call setDistributionHelper", async () => {
+    const { distHelper } = await waffle.loadFixture(fixture);
+    await expect(
+      goodReserve.setDistributionHelper(distHelper.address, 1000)
+    ).to.be.revertedWith("avatar");
+  });
+
+  it("should send UBI to distribution contract", async () => {
+    const { distHelper } = await waffle.loadFixture(deployed_fixture);
+
+    await increaseTime(60 * 60 * 24 * 365); //required for reserve ratio advance
+    await setDAOAddress("FUND_MANAGER", founder.address); //required so we can call mintUBI
+
+    let tx = await (
+      await goodReserve.connect(founder).mintUBI(0, 0, cDai)
+    ).wait();
+
+    const nonUbiMintedEvent = tx.events.find(_ => _.event === "NonUBIMinted");
+    const ubiMintedEvent = tx.events.find(_ => _.event === "UBIMinted");
+
+    //verify amount transfered
+    expect(nonUbiMintedEvent.args.amountMinted).gt(0);
+    expect(nonUbiMintedEvent.args.amountMinted).to.equal(
+      await goodDollar.balanceOf(distHelper.address)
+    );
+
+    expect(
+      nonUbiMintedEvent.args.amountMinted.add(
+        ubiMintedEvent.args.gdUbiTransferred
+      )
+    ).to.equal(ubiMintedEvent.args.gdExpansionMinted);
+  });
+
+  it("should distribute according to 10% nonUbiBps", async () => {
+    let { distHelper } = await waffle.loadFixture(deployed_fixture);
+
+    await increaseTime(60 * 60 * 24 * 365); //required for reserve ratio advance
+    await setDAOAddress("FUND_MANAGER", founder.address); //required so we can call mintUBI
+
+    let tx = await (
+      await goodReserve.connect(founder).mintUBI(0, 0, cDai)
+    ).wait();
+
+    const nonUbiMintedEvent = tx.events.find(_ => _.event === "NonUBIMinted");
+    const ubiMintedEvent = tx.events.find(_ => _.event === "UBIMinted");
+
+    //verify 10%
+    expect(nonUbiMintedEvent.args.amountMinted).gt(0);
+    expect(nonUbiMintedEvent.args.amountMinted).to.equal(
+      ubiMintedEvent.args.gdExpansionMinted.mul(1000).div(10000)
+    );
+  });
+
+  it("should distribute according to 25% nonUbiBps", async () => {
+    let { distHelper } = await waffle.loadFixture(deployed_fixture);
+
+    const encodedCall = goodReserve.interface.encodeFunctionData(
+      "setDistributionHelper",
+      [distHelper.address, 2500]
+    );
+
+    await genericCall(goodReserve.address, encodedCall, avatar.address, 0);
+
+    await increaseTime(60 * 60 * 24 * 365); //required for reserve ratio advance
+    await setDAOAddress("FUND_MANAGER", founder.address); //required so we can call mintUBI
+
+    let tx = await (
+      await goodReserve.connect(founder).mintUBI(0, 0, cDai)
+    ).wait();
+
+    const nonUbiMintedEvent = tx.events.find(_ => _.event === "NonUBIMinted");
+    const ubiMintedEvent = tx.events.find(_ => _.event === "UBIMinted");
+
+    //verify 10%
+    expect(nonUbiMintedEvent.args.amountMinted).gt(0);
+    expect(nonUbiMintedEvent.args.amountMinted).to.equal(
+      ubiMintedEvent.args.gdExpansionMinted.mul(2500).div(10000)
+    );
+  });
+
+  it("should distribute even when DistributionHelper onDistribution reverts", async () => {
+    let { distHelper } = await waffle.loadFixture(deployed_revert_fixture); //using DistributionHelperTest which reverts
+
+    await increaseTime(60 * 60 * 24 * 365); //required for reserve ratio advance
+    await setDAOAddress("FUND_MANAGER", founder.address); //required so we can call mintUBI
+
+    let tx = await (
+      await goodReserve.connect(founder).mintUBI(0, 0, cDai)
+    ).wait();
+
+    const nonUbiMintedEvent = tx.events.find(_ => _.event === "NonUBIMinted");
+    const ubiMintedEvent = tx.events.find(_ => _.event === "UBIMinted");
+
+    const topic = distHelper.filters.Distribution().topics[0];
+    const distributionEvent = tx.events.find(_ =>
+      _.topics.includes(topic as string)
+    );
+
+    //verify onDistribution didnt happen
+    expect(distributionEvent).to.be.undefined;
+
+    //verify 10%
+    expect(nonUbiMintedEvent.args.amountMinted).gt(0);
+    expect(nonUbiMintedEvent.args.amountMinted).to.equal(
+      ubiMintedEvent.args.gdExpansionMinted.mul(1000).div(10000)
+    );
+  });
+
+  it("should trigger onDistribution of DistributionHelper", async () => {
+    let { distHelper } = await waffle.loadFixture(deployed_fixture); //using DistributionHelperTest which reverts
+
+    await increaseTime(60 * 60 * 24 * 365); //required for reserve ratio advance
+    await setDAOAddress("FUND_MANAGER", founder.address); //required so we can call mintUBI
+
+    let tx = await (
+      await goodReserve.connect(founder).mintUBI(0, 0, cDai)
+    ).wait();
+
+    const topic = distHelper.filters.Distribution().topics[0];
+    const distributionEvent = tx.events.find(_ =>
+      _.topics.includes(topic as string)
+    );
+
+    expect(distributionEvent).not.empty;
+  });
+
+  it("should not try to distribute UBI if bps=0", async () => {
+    let { distHelper } = await waffle.loadFixture(deployed_fixture);
+
+    await increaseTime(60 * 60 * 24 * 365); //required for reserve ratio advance
+    await setDAOAddress("FUND_MANAGER", founder.address); //required so we can call mintUBI
+
+    const encodedCall = goodReserve.interface.encodeFunctionData(
+      "setDistributionHelper",
+      [distHelper.address, 0]
+    );
+
+    await genericCall(goodReserve.address, encodedCall, avatar.address, 0);
+
+    let tx = await (
+      await goodReserve.connect(founder).mintUBI(0, 0, cDai)
+    ).wait();
+
+    const nonUbiMintedEvent = tx.events.find(_ => _.event === "NonUBIMinted");
+
+    expect(nonUbiMintedEvent).to.be.undefined;
+  });
+
+  it("should not try to distribute UBI if distributionhelper is null", async () => {
+    let { distHelper } = await waffle.loadFixture(deployed_fixture); //using DistributionHelperTest which reverts
+
+    await increaseTime(60 * 60 * 24 * 365); //required for reserve ratio advance
+    await setDAOAddress("FUND_MANAGER", founder.address); //required so we can call mintUBI
+
+    const encodedCall = goodReserve.interface.encodeFunctionData(
+      "setDistributionHelper",
+      [ethers.constants.AddressZero, 1000]
+    );
+
+    await genericCall(goodReserve.address, encodedCall, avatar.address, 0);
+
+    let tx = await (
+      await goodReserve.connect(founder).mintUBI(0, 0, cDai)
+    ).wait();
+
+    const nonUbiMintedEvent = tx.events.find(_ => _.event === "NonUBIMinted");
+
+    expect(nonUbiMintedEvent).to.be.undefined;
+  });
+});

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

@@ -8,7 +8,7 @@ import { createDAO, increaseTime, advanceBlocks } from "../helpers";
 import ContributionCalculation from "@gooddollar/goodcontracts/stakingModel/build/contracts/ContributionCalculation.json";
 
 const BN = ethers.BigNumber;
-const RANDOM_GDX_MERKLEROOT1 = 
+const RANDOM_GDX_MERKLEROOT1 =
   "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 export const NULL_ADDRESS = ethers.constants.AddressZero;
 export const BLOCK_INTERVAL = 1;
@@ -61,14 +61,14 @@ describe("GDX Token", () => {
     goodReserve = reserve as GoodReserveCDai;
     genericCall = gn;
     runAsAvatarOnly = raao;
-    
+
     console.log("deployed dao", {
       founder: founder.address,
       gd,
       identity,
       controller,
       avatar,
-      goodReserve: goodReserve.address,
+      goodReserve: goodReserve.address
     });
 
     goodDollar = await ethers.getContractAt("IGoodDollar", gd);
@@ -82,7 +82,7 @@ describe("GDX Token", () => {
     const reserveFactory = await ethers.getContractFactory("GoodReserveCDai");
 
     console.log("deployed contribution, deploying reserve...", {
-      founder: founder.address,
+      founder: founder.address
     });
 
     console.log("setting permissions...");
@@ -184,7 +184,7 @@ describe("GDX Token", () => {
       await goodReserve.sell(amount, 0, NULL_ADDRESS, NULL_ADDRESS)
     ).wait();
 
-    const event = transaction.events.find((_) => _.event === "TokenSold");
+    const event = transaction.events.find(_ => _.event === "TokenSold");
     expect(event.args.contributionAmount).to.equal(0);
   });
   it("GDX should be 2 decimals", async () => {
@@ -203,7 +203,7 @@ describe("GDX Token", () => {
         .sell(amount, 0, founder.address, NULL_ADDRESS)
     ).wait();
 
-    const event = transaction.events.find((_) => _.event === "TokenSold");
+    const event = transaction.events.find(_ => _.event === "TokenSold");
     const gdxAfter = await goodReserve["balanceOf(address)"](staker.address);
 
     expect(gdxAfter).to.equal(0, "gdx not burned");
@@ -221,7 +221,7 @@ describe("GDX Token", () => {
       await goodReserve.sell(amount, 0, NULL_ADDRESS, NULL_ADDRESS)
     ).wait();
 
-    const event = transaction.events.find((_) => _.event === "TokenSold");
+    const event = transaction.events.find(_ => _.event === "TokenSold");
     const gdxAfter = await goodReserve["balanceOf(address)"](founder.address);
 
     expect(gdxAfter).to.equal(0, "gdx not burned");
@@ -236,7 +236,7 @@ describe("GDX Token", () => {
     let reserve = (await rFactory.deploy()) as GoodReserveCDai;
     const airdropBytes = ethers.utils.defaultAbiCoder.encode(
       ["address[]", "uint256[]"],
-      [signers.map((_) => _.address), signers.map((_) => 1000)]
+      [signers.map(_ => _.address), signers.map(_ => 1000)]
     );
 
     await reserve["initialize(address,bytes32)"](
@@ -256,11 +256,16 @@ describe("GDX Token", () => {
     );
   });
 
-  it("should set GDX airdrop by avatar", async () => {
-    await runAsAvatarOnly(goodReserve,"setGDXAirdrop(bytes32)", RANDOM_GDX_MERKLEROOT1);
+  xit("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 originalGDXAirdrop =
+      "0x26ef809f3f845395c0bc66ce1eea85146516cb99afd030e2085b13e79514e94c";
     const encodedCall = goodReserve.interface.encodeFunctionData(
       "setGDXAirdrop",
       [originalGDXAirdrop]
@@ -269,7 +274,7 @@ describe("GDX Token", () => {
   });
 
   //check sample proof generated by gdxAirdropCalculation.ts script
-  it("should be able to claim gdx", async () => {
+  xit("should be able to claim gdx", async () => {
     await goodReserve.claimGDX(
       "0x0EeBBbbf6f97e73dd1d59e4F17666B36Ea12dD85",
       1436983746,
@@ -279,7 +284,7 @@ describe("GDX Token", () => {
         "0xf0db8914b45ce55ea25be091e1fe4d897db4cff19e1b1680c37061a30a95c102",
         "0xc6e2cbda2531c708550b3856fc208355b184483e19ad6d8877a541c441ad3fef",
         "0x355c34cc000364d5a1cebe4835197936bc5966e3e8ac116a8fa20a8d2714f7c5",
-        "0xd515f7a623c1a18396a6aececcdcae32818b64faa0f536103b3a32e8c5ae7643",
+        "0xd515f7a623c1a18396a6aececcdcae32818b64faa0f536103b3a32e8c5ae7643"
       ]
     );
     expect(
@@ -294,7 +299,7 @@ describe("GDX Token", () => {
     ).to.be.true;
   });
 
-  it("should not be able to claim gdx twice", async () => {
+  xit("should not be able to claim gdx twice", async () => {
     const tx = goodReserve.claimGDX(
       "0x0EeBBbbf6f97e73dd1d59e4F17666B36Ea12dD85",
       1436983746,
@@ -304,7 +309,7 @@ describe("GDX Token", () => {
         "0xf0db8914b45ce55ea25be091e1fe4d897db4cff19e1b1680c37061a30a95c102",
         "0xc6e2cbda2531c708550b3856fc208355b184483e19ad6d8877a541c441ad3fef",
         "0x355c34cc000364d5a1cebe4835197936bc5966e3e8ac116a8fa20a8d2714f7c5",
-        "0xd515f7a623c1a18396a6aececcdcae32818b64faa0f536103b3a32e8c5ae7643",
+        "0xd515f7a623c1a18396a6aececcdcae32818b64faa0f536103b3a32e8c5ae7643"
       ]
     );
     await expect(tx).to.be.revertedWith("already claimed gdx");

package/test/reserve/GoodReserveCDai.pause.test.ts

@@ -0,0 +1,116 @@
+import { ethers, waffle } from "hardhat";
+import { expect } from "chai";
+import { GoodReserveCDai, DistributionHelper } from "../../types";
+import { createDAO, increaseTime } from "../helpers";
+import { Contract } from "ethers";
+import { FormatTypes } from "@ethersproject/abi";
+
+const BN = ethers.BigNumber;
+export const NULL_ADDRESS = ethers.constants.AddressZero;
+export const BLOCK_INTERVAL = 1;
+
+describe("GoodReserve - Distribution Helper", () => {
+  let goodReserve: GoodReserveCDai;
+  let goodDollar: Contract,
+    genericCall,
+    avatar,
+    founder,
+    signers,
+    dai,
+    cDAI,
+    setDAOAddress;
+
+  before(async () => {
+    [founder, ...signers] = await ethers.getSigners();
+
+    let {
+      controller: ctrl,
+      avatar: av,
+      gd,
+      identity,
+      setDAOAddress: sda,
+      setSchemes,
+      reserve,
+      daiAddress,
+      cdaiAddress,
+      genericCall: gc
+    } = await createDAO();
+
+    dai = await ethers.getContractAt("DAIMock", daiAddress);
+    cDAI = await ethers.getContractAt("cDAIMock", cdaiAddress);
+
+    genericCall = gc;
+    avatar = av;
+    setDAOAddress = sda;
+
+    console.log("deployed dao", {
+      founder: founder.address,
+      gd,
+      identity,
+      avatar
+    });
+
+    goodDollar = await ethers.getContractAt("IGoodDollar", gd);
+
+    console.log("deployed contribution, deploying reserve...", {
+      founder: founder.address
+    });
+
+    goodReserve = reserve as GoodReserveCDai;
+
+    console.log("setting permissions...");
+  });
+
+  const fixture = async (wallets, provider) => {
+    let encodedCall = goodReserve.interface.encodeFunctionData("grantRole", [
+      await goodReserve.PAUSER_ROLE(),
+      avatar
+    ]);
+    await genericCall(goodReserve.address, encodedCall);
+
+    encodedCall = goodReserve.interface.encodeFunctionData("pause");
+    await genericCall(goodReserve.address, encodedCall);
+
+    return { goodReserve };
+  };
+
+  it("should allow avatar to unpause", async () => {
+    const { goodReserve } = await waffle.loadFixture(fixture);
+    const encodedCall = goodReserve.interface.encodeFunctionData("unpause");
+
+    expect(await goodReserve.paused()).to.equal(true);
+    await genericCall(goodReserve.address, encodedCall);
+
+    expect(await goodReserve.paused()).to.equal(false);
+  });
+
+  it("should not be able to buy when paused", async () => {
+    let amount = 1e8;
+    const { goodReserve } = await waffle.loadFixture(fixture);
+    await dai["mint(uint256)"](ethers.utils.parseEther("100"));
+    await dai.approve(cDAI.address, ethers.utils.parseEther("100"));
+    await cDAI["mint(uint256)"](ethers.utils.parseEther("100"));
+    await cDAI.approve(goodReserve.address, ethers.utils.parseEther("10"));
+    await expect(goodReserve.buy(amount, 0, founder.address)).revertedWith(
+      "paused"
+    );
+  });
+
+  it("should not be able to sell when paused", async () => {
+    const { goodReserve } = await waffle.loadFixture(fixture);
+    await expect(
+      goodReserve.sell(1, 0, founder.address, founder.address)
+    ).revertedWith("paused");
+  });
+
+  it("should not be able to mint when paused", async () => {
+    const { goodReserve } = await waffle.loadFixture(fixture);
+    await setDAOAddress("FUND_MANAGER", founder.address);
+
+    await expect(
+      goodReserve
+        .connect(founder)
+        .mintRewardFromRR(cDAI.address, founder.address, 1000)
+    ).revertedWith("paused"); //10000 cdai wei is 1G$
+  });
+});