@gooddollar/goodprotocol 2.0.21 → 2.0.22-beta.0

package/test/reserve/DistributionHelper.test.ts

@@ -1,11 +1,14 @@
 import { ethers, upgrades, artifacts } from "hardhat";
-import { loadFixture, setCode } from "@nomicfoundation/hardhat-network-helpers";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
-import { GoodReserveCDai, DistributionHelperTestHelper, DistributionBridgeMock, IGoodDollar } from "../../types";
+import {
+  GoodReserveCDai,
+  DistributionHelperTestHelper,
+  DistributionBridgeMock,
+  IGoodDollar
+} from "../../types";
 import { createDAO, increaseTime } from "../helpers";
-import { FormatTypes } from "@ethersproject/abi";
 import * as waffle from "ethereum-waffle";
-import { BaseContract } from "ethers";
 
 const BN = ethers.BigNumber;
 export const NULL_ADDRESS = ethers.constants.AddressZero;
@@ -13,7 +16,14 @@ export const BLOCK_INTERVAL = 1;
 
 describe("DistributionHelper", () => {
   let goodReserve: GoodReserveCDai;
-  let goodDollar: IGoodDollar, genericCall, avatar, founder, signers, setDAOAddress, nameService, cDai;
+  let goodDollar: IGoodDollar,
+    genericCall,
+    avatar,
+    founder,
+    signers,
+    setDAOAddress,
+    nameService,
+    cDai;
 
   before(async () => {
     [founder, ...signers] = await ethers.getSigners();
@@ -67,19 +77,27 @@ describe("DistributionHelper", () => {
     await distHelper.setOracle(oracle.address);
 
     //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", [
-      {
-        axelarBaseFeeUSD: "100000000000000000",
-        bridgeExecuteGas: 400000,
-        targetChainGasPrice: 5e9,
-        maxFee: "5000000000000000",
-        minBalanceForFees: "10000000000000000",
-        percentageToSellForFee: "5"
-      }
-    ]);
+    await founder.sendTransaction({
+      to: distHelper.address,
+      value: ethers.constants.WeiPerEther
+    });
+    const bridge = (await ethers.deployContract(
+      "DistributionBridgeMock"
+    )) as DistributionBridgeMock;
+
+    const encodedCall = distHelper.interface.encodeFunctionData(
+      "setFeeSettings",
+      [
+        {
+          axelarBaseFeeUSD: "100000000000000000",
+          bridgeExecuteGas: 400000,
+          targetChainGasPrice: 5e9,
+          maxFee: "5000000000000000",
+          minBalanceForFees: "10000000000000000",
+          percentageToSellForFee: "5"
+        }
+      ]
+    );
 
     await genericCall(distHelper.address, encodedCall, avatar.address, 0);
 
@@ -100,7 +118,9 @@ describe("DistributionHelper", () => {
         addr: recipient.address,
         transferType: 0
       })
-    ).to.be.revertedWith("is missing role 0x0000000000000000000000000000000000000000000000000000000000000000");
+    ).to.be.revertedWith(
+      /is missing role 0x0000000000000000000000000000000000000000000000000000000000000000/
+    );
   });
 
   it("should allow to add recipient by avatar", async () => {
@@ -108,14 +128,17 @@ describe("DistributionHelper", () => {
 
     const recipient = signers[0];
 
-    const encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
-      {
-        bps: 3000,
-        chainId: 42220,
-        addr: recipient.address,
-        transferType: 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);
@@ -130,30 +153,40 @@ describe("DistributionHelper", () => {
 
     const recipient = signers[0];
 
-    let encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
-      {
-        bps: 1000,
-        chainId: 2,
-        addr: recipient.address,
-        transferType: 1
-      }
-    ]);
+    let encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 1000,
+          chainId: 2,
+          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: 2
-      }
-    ]);
+    encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 1500,
+          chainId: 45,
+          addr: recipient.address,
+          transferType: 2
+        }
+      ]
+    );
 
     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 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);
@@ -167,20 +200,25 @@ describe("DistributionHelper", () => {
 
     const recipient = signers[0];
 
-    let encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
-      {
-        bps: 2000,
-        chainId: 42220,
-        addr: recipient.address,
-        transferType: 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 distHelper.onDistribution("100000000000");
-    expect(await goodDollar.balanceOf(bridge.address)).to.equal((100000000000 * 2000) / 10000);
+    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);
@@ -193,21 +231,29 @@ describe("DistributionHelper", () => {
 
     const recipient = signers[0];
 
-    let encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
-      {
-        bps: 2000,
-        chainId: 42220,
-        addr: recipient.address, //needs to be a contract for transferAndCall to work
-        transferType: 1
-      }
-    ]);
+    let encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 2000,
+          chainId: 42220,
+          addr: recipient.address, //needs to be a contract for transferAndCall to work
+          transferType: 1
+        }
+      ]
+    );
 
     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 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);
+    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);
@@ -221,28 +267,38 @@ describe("DistributionHelper", () => {
 
     const recipient = signers[0];
 
-    let encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
-      {
-        bps: 2000,
-        chainId: 42220,
-        addr: recipient.address, //needs to be a contract for transferAndCall to work
-        transferType: 2
-      }
-    ]);
+    let encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 2000,
+          chainId: 42220,
+          addr: recipient.address, //needs to be a contract for transferAndCall to work
+          transferType: 2
+        }
+      ]
+    );
 
     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 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);
+    expect(
+      await goodDollar.allowance(distHelper.address, bridge.address)
+    ).to.equal((100000000000 * 2000) / 10000);
 
     const events = await bridge.queryFilter(bridge.filters.BridgeAxl());
     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(2.2e13); //fee should be 2e13 with 10% extra
-    expect(events[0].args.gasRefund).to.equal(await distHelper.getTargetChainRefundAddress(42220));
+    expect(events[0].args.gasRefund).to.equal(
+      await distHelper.getTargetChainRefundAddress(42220)
+    );
   });
 
   it("should distribute via transferAndCall", async () => {
@@ -250,20 +306,25 @@ describe("DistributionHelper", () => {
 
     const recipient = signers[0];
 
-    let encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
-      {
-        bps: 2555,
-        chainId: 42220,
-        addr: signers[0].address,
-        transferType: 3
-      }
-    ]);
+    let encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 2555,
+          chainId: 42220,
+          addr: signers[0].address,
+          transferType: 3
+        }
+      ]
+    );
 
     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[0].address)).to.equal(
+      (100000000000 * 2555) / 10000
+    );
   });
 
   it("should distribute to multiple recipients", async () => {
@@ -271,44 +332,59 @@ describe("DistributionHelper", () => {
 
     const recipient = signers[0];
 
-    let encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
-      {
-        bps: 2555,
-        chainId: 42220,
-        addr: signers[0].address,
-        transferType: 3
-      }
-    ]);
+    let encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 2555,
+          chainId: 42220,
+          addr: signers[0].address,
+          transferType: 3
+        }
+      ]
+    );
 
     await genericCall(distHelper.address, encodedCall, avatar.address, 0);
 
-    encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
-      {
-        bps: 1000,
-        chainId: 42220,
-        addr: signers[1].address,
-        transferType: 3
-      }
-    ]);
+    encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 1000,
+          chainId: 42220,
+          addr: signers[1].address,
+          transferType: 3
+        }
+      ]
+    );
 
     await genericCall(distHelper.address, encodedCall, avatar.address, 0);
 
-    encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
-      {
-        bps: 5,
-        chainId: 42220,
-        addr: signers[2].address,
-        transferType: 3
-      }
-    ]);
+    encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 5,
+          chainId: 42220,
+          addr: signers[2].address,
+          transferType: 3
+        }
+      ]
+    );
 
     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);
+    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 () => {
@@ -316,45 +392,62 @@ describe("DistributionHelper", () => {
 
     const recipient = signers[0];
 
-    let encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
-      {
-        bps: 2555,
-        chainId: 42220,
-        addr: signers[0].address,
-        transferType: 3
-      }
-    ]);
+    let encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 2555,
+          chainId: 42220,
+          addr: signers[0].address,
+          transferType: 3
+        }
+      ]
+    );
 
     await genericCall(distHelper.address, encodedCall, avatar.address, 0);
 
-    encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
-      {
-        bps: 1000,
-        chainId: 42220,
-        addr: signers[1].address,
-        transferType: 3
-      }
-    ]);
+    encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 1000,
+          chainId: 42220,
+          addr: signers[1].address,
+          transferType: 3
+        }
+      ]
+    );
 
     await genericCall(distHelper.address, encodedCall, avatar.address, 0);
 
-    encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
-      {
-        bps: 5,
-        chainId: 42220,
-        addr: signers[2].address,
-        transferType: 3
-      }
-    ]);
+    encodedCall = distHelper.interface.encodeFunctionData(
+      "addOrUpdateRecipient",
+      [
+        {
+          bps: 5,
+          chainId: 42220,
+          addr: signers[2].address,
+          transferType: 3
+        }
+      ]
+    );
 
     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);
+    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

@@ -1,4 +1,4 @@
-import { default as hre, ethers, upgrades, waffle } from "hardhat";
+import { default as hre, ethers, upgrades } from "hardhat";
 import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { GoodMarketMaker, CERC20 } from "../../types";
@@ -176,7 +176,7 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       ethers.utils.parseEther("2")
     );
     await expect(res).to.be.revertedWith(
-      "GD amount is lower than the contribution amount"
+      /GD amount is lower than the contribution amount/
     );
   });
 
@@ -194,14 +194,14 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
     let res = marketMaker.connect(staker).mintInterest(cdai, BN.from(1e8));
 
     await expect(res).to.be.revertedWith(
-      "GoodMarketMaker: not Reserve or Avatar"
+      /GoodMarketMaker: not Reserve or Avatar/
     );
   });
 
   it("should not be able to mint expansion by a non owner", async () => {
     let res = marketMaker.connect(staker).mintExpansion(cdai);
     await expect(res).to.be.revertedWith(
-      "GoodMarketMaker: not Reserve or Avatar"
+      /GoodMarketMaker: not Reserve or Avatar/
     );
   });
 
@@ -217,21 +217,21 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
   it("should be able to update the reserve ratio only by the owner", async () => {
     let res = marketMaker.connect(staker).expandReserveRatio(cdai);
     await expect(res).to.be.revertedWith(
-      "GoodMarketMaker: not Reserve or Avatar"
+      /GoodMarketMaker: not Reserve or Avatar/
     );
   });
 
   it("should be able to mint interest only by the owner", async () => {
     let res = marketMaker.connect(staker).mintInterest(cdai, BN.from(1e8));
     await expect(res).to.be.revertedWith(
-      "GoodMarketMaker: not Reserve or Avatar"
+      /GoodMarketMaker: not Reserve or Avatar/
     );
   });
 
   it("should be able to mint expansion only by the owner", async () => {
     let res = marketMaker.connect(staker).mintExpansion(cdai);
     await expect(res).to.be.revertedWith(
-      "GoodMarketMaker: not Reserve or Avatar"
+      /GoodMarketMaker: not Reserve or Avatar/
     );
   });
 
@@ -412,21 +412,21 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       .connect(staker)
       .buy(dai, ethers.utils.parseEther("1"));
     await expect(res).to.be.revertedWith(
-      "GoodMarketMaker: not Reserve or Avatar"
+      /GoodMarketMaker: not Reserve or Avatar/
     );
   });
 
   it("should not be able to calculate the sell return in reserve token and update the bonding curve params by a non-owner account", async () => {
     let res = marketMaker.connect(staker).sellWithContribution(dai, 100, 0);
     await expect(res).to.be.revertedWith(
-      "GoodMarketMaker: not Reserve or Avatar"
+      /GoodMarketMaker: not Reserve or Avatar/
     );
   });
 
   it("should not be able to calculate the sellWithContribution return in reserve token and update the bonding curve params by a non-owner account", async () => {
     let res = marketMaker.connect(staker).sellWithContribution(dai, 100, 80);
     await expect(res).to.be.revertedWith(
-      "GoodMarketMaker: not Reserve or Avatar"
+      /GoodMarketMaker: not Reserve or Avatar/
     );
   });
 
@@ -442,7 +442,7 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       reserveRatioBefore.toString()
     );
     let res = marketMaker.buy(cdai, ethers.utils.parseEther("1"));
-    await expect(res).to.be.revertedWith("Reserve token not initialized");
+    await expect(res).to.be.revertedWith(/Reserve token not initialized/);
     await initializeToken(
       cdai,
       gdSupplyBefore,
@@ -458,7 +458,7 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       0
     );
 
-    await expect(res).to.be.revertedWith("Reserve token not initialized");
+    await expect(res).to.be.revertedWith(/Reserve token not initialized/);
   });
 
   it("should be able to sellWithContribution only with active token", async () => {
@@ -467,7 +467,7 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       ethers.utils.parseEther("1"),
       ethers.utils.parseEther("1")
     );
-    await expect(res).to.be.revertedWith("Reserve token not initialized");
+    await expect(res).to.be.revertedWith(/Reserve token not initialized/);
   });
 
   it("should be able to sell gd only when the amount is lower than the total supply", async () => {
@@ -479,7 +479,7 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       0
     );
     await expect(res).to.be.revertedWith(
-      "GD amount is higher than the total supply"
+      /GD amount is higher than the total supply/
     );
   });
 
@@ -510,7 +510,7 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
       .connect(staker)
       .setReserveRatioDailyExpansion(1, 1e15);
     await expect(res).to.be.revertedWith(
-      "GoodMarketMaker: not Reserve or Avatar"
+      /GoodMarketMaker: not Reserve or Avatar/
     );
   });
 
@@ -598,7 +598,7 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
     const invalidZeroDenominator = 0;
     await expect(
       marketMaker.setReserveRatioDailyExpansion(1, invalidZeroDenominator)
-    ).to.be.revertedWith("denominator must be above 0");
+    ).to.be.revertedWith(/denominator must be above 0/);
 
     const denominator = 1;
     const nominatorHigherThanDenom = 2;
@@ -607,6 +607,6 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
         nominatorHigherThanDenom,
         denominator
       )
-    ).to.be.revertedWith("Invalid nom or denom value");
+    ).to.be.revertedWith(/Invalid nom or denom value/);
   });
 });