@gooddollar/goodprotocol 2.0.31 → 2.0.32

package/test/reserve/CeloDistributionHelper.test.ts

@@ -0,0 +1,377 @@
+import { ethers, upgrades, artifacts } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { expect } from "chai";
+import {
+  GoodReserveCDai,
+  CeloDistributionHelperTestHelper,
+  DistributionBridgeMock,
+  IGoodDollar
+} from "../../types";
+import { createDAO, increaseTime } from "../helpers";
+import * as waffle from "ethereum-waffle";
+
+const BN = ethers.BigNumber;
+export const NULL_ADDRESS = ethers.constants.AddressZero;
+export const BLOCK_INTERVAL = 1;
+
+describe("CeloDistributionHelper", () => {
+  let goodReserve: GoodReserveCDai;
+  let goodDollar: IGoodDollar,
+    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 loadFixture(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)) as IGoodDollar;
+
+    console.log("deployed contribution, deploying reserve...", {
+      founder: founder.address
+    });
+
+    goodReserve = reserve as GoodReserveCDai;
+  });
+
+  const fixture = async () => {
+    const mpbf = await artifacts.readArtifact("IStaticOracle");
+
+    let oracle = await waffle.deployMockContract(founder, mpbf.abi);
+    oracle.mock.quoteSpecificFeeTiersWithTimePeriod.returns(1e13, []);
+    oracle.mock.prepareSpecificFeeTiersWithTimePeriod.returns([]);
+
+    const distHelper = (await upgrades.deployProxy(
+      await ethers.getContractFactory("CeloDistributionHelperTestHelper"),
+      [nameService.address, oracle.address],
+      { kind: "uups" }
+    )) as CeloDistributionHelperTestHelper;
+
+    //make sure disthelper has enough native token so it doesnt try to swap G$s
+    await founder.sendTransaction({
+      to: distHelper.address,
+      value: ethers.constants.WeiPerEther
+    });
+    const bridge = (await ethers.deployContract(
+      "DistributionBridgeMock"
+    )) as DistributionBridgeMock;
+
+    const encodedCall = distHelper.interface.encodeFunctionData(
+      "setFeeSettings",
+      [
+        {
+          maxFee: "5000000000000000",
+          minBalanceForFees: "10000000000000000",
+          percentageToSellForFee: "5",
+          maxSlippage: "5"
+        }
+      ]
+    );
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+    await distHelper.setBridges(bridge.address);
+
+    return { distHelper, bridge, oracle };
+  };
+
+  it("should not allow to add recipient", async () => {
+    const { distHelper } = await loadFixture(fixture);
+
+    const recipient = signers[0];
+
+    await expect(
+      distHelper.addOrUpdateRecipient({
+        bps: 3000,
+        chainId: 42220,
+        addr: recipient.address,
+        transferType: 0
+      })
+    ).to.be.revertedWith(
+      /is missing role 0x0000000000000000000000000000000000000000000000000000000000000000/
+    );
+  });
+
+  it("should allow to add recipient by avatar", async () => {
+    const { distHelper } = await loadFixture(fixture);
+
+    const recipient = signers[0];
+
+    const encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 3000,
+          chainId: 42220,
+          addr: recipient.address,
+          transferType: 0
+        }
+      ]
+    );
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+    const dr = await distHelper.distributionRecipients(0);
+    expect(dr.addr).to.equal(recipient.address);
+    expect(dr.chainId).to.equal(42220);
+    expect(dr.bps).to.equal(3000);
+    expect(dr.transferType).to.equal(0);
+  });
+
+  it("should allow to update recipient by avatar", async () => {
+    const { distHelper } = await loadFixture(fixture);
+
+    const recipient = signers[0];
+
+    let encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 1000,
+          chainId: 4447,
+          addr: recipient.address,
+          transferType: 1
+        }
+      ]
+    );
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 1500,
+          chainId: 45,
+          addr: recipient.address,
+          transferType: 0
+        }
+      ]
+    );
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    const updEvents = await distHelper.queryFilter(
+      distHelper.filters.RecipientUpdated()
+    );
+    const addEvents = await distHelper.queryFilter(
+      distHelper.filters.RecipientAdded()
+    );
+
+    const dr = await distHelper.distributionRecipients(0);
+    expect(dr.addr).to.equal(recipient.address);
+    expect(dr.chainId).to.equal(45);
+    expect(dr.bps).to.equal(1500);
+    expect(dr.transferType).to.equal(0);
+  });
+
+  it("should distribute via layerzero bridge", async () => {
+    const { distHelper, bridge } = await loadFixture(fixture);
+
+    const recipient = signers[0];
+
+    let encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 2000,
+          chainId: 42220,
+          addr: recipient.address,
+          transferType: 0
+        }
+      ]
+    );
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    await goodDollar.mint(distHelper.address, "100000000000");
+    await founder.sendTransaction({
+      to: distHelper.address,
+      value: ethers.constants.WeiPerEther
+    });
+    await distHelper.onDistribution("100000000000");
+    expect(
+      await goodDollar.allowance(distHelper.address, bridge.address)
+    ).to.equal((100000000000 * 2000) / 10000);
+
+    const events = await bridge.queryFilter(bridge.filters.BridgeLz());
+    expect(events[0].args.recipient).to.equal(recipient.address);
+    expect(events[0].args.amount).to.equal((100000000000 * 2000) / 10000);
+    expect(events[0].args.chainId).to.equal(42220);
+    expect(events[0].args.fee).to.equal(5e14);
+  });
+
+  it("should distribute via transferAndCall", async () => {
+    const { distHelper, bridge } = await loadFixture(fixture);
+
+    const recipient = signers[0];
+
+    let encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 2555,
+          chainId: 4447,
+          addr: signers[0].address,
+          transferType: 2
+        }
+      ]
+    );
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    await goodDollar.mint(distHelper.address, "100000000000");
+    await distHelper.onDistribution("100000000000");
+    expect(await goodDollar.balanceOf(signers[0].address)).to.equal(
+      (100000000000 * 2555) / 10000
+    );
+  });
+
+  it("should distribute to multiple recipients", async () => {
+    const { distHelper, bridge } = await loadFixture(fixture);
+
+    const recipient = signers[0];
+
+    let encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 2555,
+          chainId: 4447,
+          addr: signers[0].address,
+          transferType: 1
+        }
+      ]
+    );
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 1000,
+          chainId: 4447,
+          addr: signers[1].address,
+          transferType: 1
+        }
+      ]
+    );
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 5,
+          chainId: 4447,
+          addr: signers[2].address,
+          transferType: 2
+        }
+      ]
+    );
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    await goodDollar.mint(distHelper.address, "100000000000");
+    await distHelper.onDistribution("100000000000");
+    expect(await goodDollar.balanceOf(signers[0].address)).to.equal(
+      (100000000000 * 2555) / 10000
+    );
+    expect(await goodDollar.balanceOf(signers[1].address)).to.equal(
+      (100000000000 * 1000) / 10000
+    );
+    expect(await goodDollar.balanceOf(signers[2].address)).to.equal(
+      (100000000000 * 5) / 10000
+    );
+  });
+
+  it("should emit distribution event for multiple recipients", async () => {
+    const { distHelper, bridge } = await loadFixture(fixture);
+
+    let encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 2555,
+          chainId: 122,
+          addr: signers[0].address,
+          transferType: 0
+        }
+      ]
+    );
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 1000,
+          chainId: 4447,
+          addr: signers[1].address,
+          transferType: 1
+        }
+      ]
+    );
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 5,
+          chainId: 4447,
+          addr: signers[2].address,
+          transferType: 2
+        }
+      ]
+    );
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    await goodDollar.mint(distHelper.address, "100000000000");
+    await distHelper.onDistribution("100000000000");
+
+    const DistributionEvents = await distHelper.queryFilter(
+      distHelper.filters.Distribution()
+    );
+    expect(DistributionEvents[0].args.distributionRecipients[0].addr).eq(
+      signers[0].address
+    );
+    expect(DistributionEvents[0].args.distributionRecipients[1].addr).eq(
+      signers[1].address
+    );
+    expect(DistributionEvents[0].args.distributionRecipients[2].addr).eq(
+      signers[2].address
+    );
+  });
+});

package/test/reserve/GoodMarketMaker.test.ts

@@ -189,24 +189,22 @@ 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 () => {
     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(
-        (priceAfter.toNumber() / 100)).toString()
-    ).to.be.equal(Math.floor(priceBefore.toNumber() / 100).toString());
+    let priceAfter = await marketMaker.currentPrice(cdai);
 
+    expect(priceAfter).gt(0);
+    expect(priceBefore).gt(0);
+    expect(Math.floor(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)
+    priceAfter = await marketMaker.currentPrice(cdai);
 
-    console.log({ priceAfter, priceBefore })
-    expect(priceAfter).gt(0)
-    expect(priceBefore).gt(0)
+    console.log({ priceAfter, priceBefore });
+    expect(priceAfter).gt(0);
+    expect(priceBefore).gt(0);
     expect(priceAfter).to.eq(priceBefore);
   });
 
@@ -316,15 +314,18 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
     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)
+    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()
+    const expectedTotalMinted =
+      (10 ** 18 * reserveToken.gdSupply.toNumber()) /
+      reserveToken.reserveSupply.toNumber();
     expect(expectedTotalMinted).to.be.equal(1000000);
-    expect(toMint.toString()).to.be.equal(
-      (expectedTotalMinted).toString()
-    );
+    expect(toMint.toString()).to.be.equal(expectedTotalMinted.toString());
   });
 
   it("should calculate sell return with cDAI", async () => {
@@ -436,7 +437,7 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
         .toString()
     ).to.be.equal(reserveBalanceBefore.toString());
     expect(supplyBefore.sub(supplyAfter)).to.be.equal(BN.from(amount));
-    expect(rrAfter.toString()).to.be.equal(rrBefore.toString());
+    expect(rrAfter).gte(rrBefore); //with sell contribution G$ are burned and increase RR
   });
 
   it("should not be able to calculate the buy return in gd and update the bonding curve params by a non-owner account", async () => {
@@ -547,34 +548,24 @@ 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 () => {
-    await initializeToken(
-      dai,
-      6e11,
-      ethers.utils.parseEther("600000"),
-      5e5
-    );
+    await initializeToken(dai, 6e11, ethers.utils.parseEther("600000"), 5e5);
 
     const priceBefore = await marketMaker.currentPrice(dai);
 
-    await marketMaker.mintInterest(dai, ethers.utils.parseEther("100"))
+    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
-    );
+    await initializeToken(dai, 600, 600000000, 5e5);
 
     const priceBefore = await marketMaker.currentPrice(dai);
 
-    await marketMaker.mintInterest(dai, 60000)
+    await marketMaker.mintInterest(dai, 60000);
     const priceAfter = await marketMaker.currentPrice(dai);
-    expect(priceBefore).equal(200000000)
-    expect(priceAfter).equal(200020000)
+    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 () => {
@@ -624,6 +615,7 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
     expect(gdPriceAfter.lt(gdPriceBefore));
     expect(reserveRatioAfter).to.be.equal(reserveRatioBefore);
   });
+
   it("should price increase after buy gd when RR is not %100", async () => {
     let reserveTokenBefore = await marketMaker.reserveTokens(cdai);
     let gdPriceBefore = await marketMaker.currentPrice(cdai);
@@ -658,4 +650,75 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       )
     ).to.be.revertedWith(/Invalid nom or denom value/);
   });
+
+  it("should return same amount when splitting sell into two when exit fee is 0", async () => {
+    let reserveTokenBefore = await marketMaker.reserveTokens(cdai);
+    console.log({ reserveTokenBefore });
+    const res = await (
+      await marketMaker.sellWithContribution(cdai, "100000000", "0")
+    ).wait();
+    let reserveTokenAfterSale = await marketMaker.reserveTokens(cdai);
+    console.log({ reserveTokenAfterSale });
+    await marketMaker.initializeToken(
+      cdai,
+      reserveTokenBefore.gdSupply,
+      reserveTokenBefore.reserveSupply,
+      reserveTokenBefore.reserveRatio,
+      0
+    );
+    const split1 = await (
+      await marketMaker.sellWithContribution(cdai, "50000000", "0")
+    ).wait();
+    const split2 = await (
+      await marketMaker.sellWithContribution(cdai, "50000000", "0")
+    ).wait();
+    let reserveTokenAfterSplitSale = await marketMaker.reserveTokens(cdai);
+
+    expect(reserveTokenAfterSale.gdSupply).eq(
+      reserveTokenAfterSplitSale.gdSupply
+    );
+    expect(reserveTokenAfterSale.reserveSupply).eq(
+      reserveTokenAfterSplitSale.reserveSupply
+    );
+  });
+
+  it("should have minimal effect on return value when splitting sell into two txs when exit fee is non 0", async () => {
+    let reserveTokenBefore = await marketMaker.reserveTokens(cdai);
+    await marketMaker.initializeToken(
+      cdai,
+      reserveTokenBefore.gdSupply,
+      reserveTokenBefore.reserveSupply,
+      200000,
+      0
+    );
+    console.log({ reserveTokenBefore });
+    const res = await (
+      await marketMaker.sellWithContribution(cdai, "500000000", "50000000")
+    ).wait();
+    let reserveTokenAfterSale = await marketMaker.reserveTokens(cdai);
+    console.log({ reserveTokenAfterSale });
+    await marketMaker.initializeToken(
+      cdai,
+      reserveTokenBefore.gdSupply,
+      reserveTokenBefore.reserveSupply,
+      200000,
+      0
+    );
+    const split1 = await (
+      await marketMaker.sellWithContribution(cdai, "250000000", "25000000")
+    ).wait();
+    const split2 = await (
+      await marketMaker.sellWithContribution(cdai, "250000000", "25000000")
+    ).wait();
+    let reserveTokenAfterSplitSale = await marketMaker.reserveTokens(cdai);
+
+    console.log({ reserveTokenAfterSplitSale });
+    expect(reserveTokenAfterSale.gdSupply).eq(
+      reserveTokenAfterSplitSale.gdSupply
+    );
+    expect(
+      Number(reserveTokenAfterSplitSale.reserveSupply) /
+        Number(reserveTokenAfterSale.reserveSupply)
+    ).gte(0.981);
+  });
 });