@gooddollar/goodprotocol 2.0.32 → 2.0.34-beta.0

package/test/token/SuperGoodDollar.nohost.test.ts

@@ -0,0 +1,383 @@
+import { ethers } from "hardhat";
+import { assert, expect } from "chai";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import TransferAndCallMockABI from "@gooddollar/goodcontracts/build/contracts/TransferAndCallMock.json";
+import { createDAO, deploySuperGoodDollar } from "../helpers";
+import { ISuperGoodDollar } from "../../types";
+
+let sfHost,
+  founder,
+  alice,
+  bob,
+  eve,
+  newHost,
+  identityMock,
+  receiverMock,
+  sgd: ISuperGoodDollar, // stands for "SuperGoodDollar"
+  feesFormula10PctMock;
+
+const alotOfDollars = ethers.utils.parseEther("100000");
+const tenDollars = ethers.utils.parseEther("10");
+const oneDollar = ethers.utils.parseEther("1");
+const tenDollarsPerDay = "124378109452730"; // flowrate per second
+
+const initialState = async () => {};
+
+before(async function () {
+  //get accounts from hardhat
+  [founder, alice, bob, eve, newHost] = await ethers.getSigners();
+
+  await createDAO();
+
+  const sfContracts = {
+    host: ethers.constants.AddressZero
+  };
+  sfHost = sfContracts.host;
+
+  // GoodDollar specific init
+  const FeesFormulaMockFactory = await ethers.getContractFactory(
+    "FeesFormulaMock",
+    founder
+  );
+
+  const feesFormula0PctMock = await FeesFormulaMockFactory.deploy(0);
+
+  feesFormula10PctMock = await FeesFormulaMockFactory.deploy(100000);
+
+  // the zero address is a placeholder for the dao contract
+  const IdentityMockFactory = await ethers.getContractFactory(
+    "IdentityMock",
+    founder
+  );
+  identityMock = await IdentityMockFactory.deploy(
+    "0x0000000000000000000000000000000000000000"
+  );
+
+  receiverMock = await new ethers.ContractFactory(
+    TransferAndCallMockABI.abi,
+    TransferAndCallMockABI.bytecode,
+    founder
+  ).deploy();
+
+  console.log("deploying test supergooddollar...");
+  sgd = (await deploySuperGoodDollar(sfContracts, [
+    "SuperGoodDollar",
+    "SGD",
+    0, // cap
+    feesFormula0PctMock.address,
+    identityMock.address,
+    receiverMock.address,
+    founder.address
+  ])) as ISuperGoodDollar;
+
+  await sgd.mint(founder.address, alotOfDollars);
+});
+
+describe("SuperGoodDollar No Host", async function () {
+  it("check superfluid host", async () => {
+    expect(await sgd.getHost()).equal(sfHost);
+  });
+
+  it("check ERC20 metadata", async function () {
+    await loadFixture(initialState);
+    const symbol = await sgd.symbol();
+    const name = await sgd.name();
+    assert.equal(symbol, "SGD", "symbol mismatch");
+    assert.equal(name, "SuperGoodDollar", "name mismatch");
+  });
+
+  it("mint to alice", async function () {
+    await loadFixture(initialState);
+    await sgd.mint(alice.address, alotOfDollars);
+    const balAfter = await sgd.balanceOf(alice.address);
+
+    assert.equal(
+      balAfter.toString(),
+      alotOfDollars.toString(),
+      "wrong balance after mint"
+    );
+  });
+
+  it("do ERC20 transfer", async function () {
+    await loadFixture(initialState);
+    await sgd.mint(alice.address, tenDollars);
+    await sgd.connect(alice).transfer(bob.address, tenDollars);
+    const balAfter = await sgd.balanceOf(bob.address);
+
+    assert.equal(
+      balAfter.toString(),
+      tenDollars.toString(),
+      "wrong balance after transfer"
+    );
+  });
+
+  it("do ERC20 transferFrom", async function () {
+    await loadFixture(initialState);
+    await sgd.approve(alice.address, tenDollars);
+    await sgd
+      .connect(alice)
+      .transferFrom(founder.address, bob.address, tenDollars);
+    assert.equal(
+      (await sgd.balanceOf(bob.address)).toString(),
+      tenDollars.toString(),
+      "wrong balance after transferFrom"
+    );
+  });
+
+  it("pauseable", async function () {
+    await loadFixture(initialState);
+    await sgd.connect(founder).pause();
+
+    await expect(sgd.transfer(bob.address, tenDollars)).revertedWithCustomError(
+      sgd,
+      "SUPER_GOODDOLLAR_PAUSED"
+    );
+
+    await sgd.connect(founder).unpause();
+
+    await sgd.transfer(bob.address, tenDollars);
+  });
+
+  it("non-zero fees are applied", async function () {
+    await loadFixture(initialState);
+
+    await sgd.connect(founder).mint(alice.address, tenDollars);
+    await sgd.setFormula(feesFormula10PctMock.address);
+
+    await expect(
+      sgd.connect(alice).transfer(bob.address, tenDollars)
+    ).revertedWith(/Not enough balance to pay TX fee/);
+
+    // mint the extra amount needed for 10% fees
+    await sgd.mint(alice.address, oneDollar);
+    await sgd.connect(alice).transfer(bob.address, tenDollars);
+
+    // since the sender pays the fee, alice should have spent 11$ and bob received 10$
+    assert.equal(
+      (await sgd.balanceOf(alice.address)).toString(),
+      "0",
+      "alice: wrong balance after transfer"
+    );
+    assert.equal(
+      (await sgd.balanceOf(bob.address)).toString(),
+      tenDollars.toString(),
+      "bob: wrong balance after transfer"
+    );
+  });
+
+  it("non-zero fees are applied for transferFrom (verify override of _transferForm)", async function () {
+    await loadFixture(initialState);
+
+    await sgd.connect(founder).mint(alice.address, tenDollars);
+    await sgd.setFormula(feesFormula10PctMock.address);
+
+    await sgd.connect(alice).approve(founder.address, tenDollars.mul(2));
+
+    await expect(
+      sgd.connect(founder).transferFrom(alice.address, bob.address, tenDollars)
+    ).revertedWith(/Not enough balance to pay TX fee/);
+
+    // mint the extra amount needed for 10% fees
+    await sgd.connect(founder).mint(alice.address, oneDollar);
+    assert.equal(
+      (await sgd.balanceOf(alice.address)).toString(),
+      tenDollars.add(oneDollar).toString(),
+      "alice: wrong balance after mint"
+    );
+
+    await sgd
+      .connect(founder)
+      .transferFrom(alice.address, bob.address, tenDollars);
+
+    // since the sender pays the fee, alice should have spent 11$ and bob received 10$
+    assert.equal(
+      (await sgd.balanceOf(alice.address)).toString(),
+      "0",
+      "alice: wrong balance after transfer"
+    );
+    assert.equal(
+      (await sgd.balanceOf(bob.address)).toString(),
+      tenDollars.toString(),
+      "bob: wrong balance after transfer"
+    );
+  });
+
+  it("should not be able to initialize again", async () => {
+    await loadFixture(initialState);
+    await expect(
+      sgd["initialize(string,string,uint256,address,address,address,address)"](
+        "x",
+        "y",
+        1,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero
+      )
+    ).revertedWith(/Initializable: contract is already initialized/);
+
+    await expect(
+      sgd["initialize(address,uint8,string,string)"](
+        ethers.constants.AddressZero,
+        2,
+        "GD",
+        "GD"
+      )
+    ).revertedWith(/Initializable: contract is not initializing/);
+  });
+
+  it("update the GoodDollar logic", async function () {
+    await loadFixture(initialState);
+    const sgdProxiable = await ethers.getContractAt(
+      "contracts/token/superfluid/UUPSProxiable.sol:UUPSProxiable",
+      sgd.address,
+      founder.signer
+    );
+
+    const auxCodeAddrBefore = await sgdProxiable.getCodeAddress();
+
+    const newLogic = await (
+      await ethers.getContractFactory("SuperGoodDollar", founder)
+    ).deploy(newHost.address);
+
+    await expect(
+      sgdProxiable.connect(eve).updateCode(newLogic.address)
+    ).revertedWith(/not owner/);
+
+    await sgdProxiable.connect(founder).updateCode(newLogic.address);
+
+    const auxCodeAddrAfter = await sgdProxiable.getCodeAddress();
+
+    assert.notEqual(
+      auxCodeAddrBefore,
+      auxCodeAddrAfter,
+      "code address unchanged"
+    );
+
+    expect(await sgd.getHost()).equal(newHost.address);
+    await expect(
+      sgd["initialize(string,string,uint256,address,address,address,address)"](
+        "x",
+        "y",
+        1,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero
+      )
+    ).revertedWith(/Initializable: contract is already initialized/);
+  });
+
+  describe("ERC20Permit", () => {
+    const name = "SuperGoodDollar";
+    const version = "1";
+
+    const Permit = [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "nonce", type: "uint256" },
+      { name: "deadline", type: "uint256" }
+    ];
+
+    it("initial nonce is 0", async function () {
+      expect(await sgd.nonces(alice.address)).to.equal(0);
+    });
+
+    it("domain separator", async function () {
+      const hashedDomain = await ethers.utils._TypedDataEncoder.hashDomain({
+        name,
+        version,
+        chainId: 4447,
+        verifyingContract: sgd.address
+      });
+      expect(await sgd.DOMAIN_SEPARATOR()).to.equal(hashedDomain);
+    });
+
+    describe("permit", function () {
+      const wallet = ethers.Wallet.createRandom();
+
+      const chainId = 4447;
+      const owner = wallet.address;
+      const value = 42;
+      const nonce = 0;
+      const maxDeadline = ethers.constants.MaxUint256;
+
+      const buildData = (
+        chainId,
+        verifyingContract,
+        deadline = maxDeadline
+      ) => ({
+        primaryType: "Permit",
+        types: { Permit },
+        domain: { name, version, chainId, verifyingContract },
+        message: { owner, spender: bob.address, value, nonce, deadline }
+      });
+
+      it("accepts owner signature", async function () {
+        const data = buildData(chainId, sgd.address);
+        const signature = await wallet._signTypedData(
+          data.domain,
+          data.types,
+          data.message
+        );
+        const { v, r, s } = ethers.utils.splitSignature(signature);
+
+        await sgd.permit(owner, bob.address, value, maxDeadline, v, r, s);
+
+        expect(await sgd.nonces(owner)).to.equal(1);
+        expect(await sgd.allowance(owner, bob.address)).to.equal(value);
+      });
+
+      it("rejects reused signature", async function () {
+        await loadFixture(initialState);
+
+        const data = buildData(chainId, sgd.address);
+        const signature = await wallet._signTypedData(
+          data.domain,
+          data.types,
+          data.message
+        );
+        const { v, r, s } = ethers.utils.splitSignature(signature);
+
+        await sgd.permit(owner, bob.address, value, maxDeadline, v, r, s);
+
+        await expect(
+          sgd.permit(owner, bob.address, value, maxDeadline, v, r, s)
+        ).revertedWith(/ERC20Permit: invalid signature/);
+      });
+
+      it("rejects other signature", async function () {
+        const otherWallet = ethers.Wallet.createRandom();
+        const data = buildData(chainId, sgd.address);
+        const signature = await otherWallet._signTypedData(
+          data.domain,
+          data.types,
+          data.message
+        );
+        const { v, r, s } = ethers.utils.splitSignature(signature);
+
+        await expect(
+          sgd.permit(owner, bob.address, value, maxDeadline, v, r, s)
+        ).revertedWith(/ERC20Permit: invalid signature/);
+      });
+
+      it("rejects expired permit", async function () {
+        const block = await ethers.provider.getBlock("latest");
+        const deadline = ethers.BigNumber.from(block.timestamp.toFixed(0));
+
+        const data = buildData(chainId, sgd.address, deadline);
+        const signature = await wallet._signTypedData(
+          data.domain,
+          data.types,
+          data.message
+        );
+        const { v, r, s } = ethers.utils.splitSignature(signature);
+
+        await expect(
+          sgd.permit(owner, bob.address, value, deadline, v, r, s)
+        ).revertedWith(/ERC20Permit: expired deadline/);
+      });
+    });
+  });
+});

package/test/token/SuperGoodDollar.test.ts

@@ -249,17 +249,13 @@ describe("SuperGoodDollar", async function () {
   it("should not be able to initialize again", async () => {
     await loadFixture(initialState);
     await expect(
-      sgd[
-        "initialize(string,string,uint256,address,address,address,address,address,address)"
-      ](
+      sgd["initialize(string,string,uint256,address,address,address,address)"](
         "x",
         "y",
         1,
         ethers.constants.AddressZero,
         ethers.constants.AddressZero,
         ethers.constants.AddressZero,
-        ethers.constants.AddressZero,
-        ethers.constants.AddressZero,
         ethers.constants.AddressZero
       )
     ).revertedWith(/Initializable: contract is already initialized/);
@@ -304,17 +300,13 @@ describe("SuperGoodDollar", async function () {
 
     expect(await sgd.getHost()).equal(newHost.address);
     await expect(
-      sgd[
-        "initialize(string,string,uint256,address,address,address,address,address,address)"
-      ](
+      sgd["initialize(string,string,uint256,address,address,address,address)"](
         "x",
         "y",
         1,
         ethers.constants.AddressZero,
         ethers.constants.AddressZero,
         ethers.constants.AddressZero,
-        ethers.constants.AddressZero,
-        ethers.constants.AddressZero,
         ethers.constants.AddressZero
       )
     ).revertedWith(/Initializable: contract is already initialized/);

package/test/ubi/UBIScheme.e2e.test.ts

@@ -235,7 +235,7 @@ describe("UBIScheme - network e2e tests", () => {
     );
   });
 
-  it("should not be able to fish an active user", async () => {
+  it.skip("should not be able to fish an active user", async () => {
     let error = await ubi
       .connect(fisherman)
       .fish(claimer.address)
@@ -244,7 +244,7 @@ describe("UBIScheme - network e2e tests", () => {
     expect(error.message).to.have.string("can't fish");
   });
 
-  it("should be able to fish inactive user", async () => {
+  it.skip("should be able to fish inactive user", async () => {
     await increaseTime(MAX_INACTIVE_DAYS * 86700);
     let balance1 = await goodDollar.balanceOf(fisherman.address);
     await ubi.connect(fisherman).fish(claimer.address);
@@ -257,7 +257,7 @@ describe("UBIScheme - network e2e tests", () => {
     );
   });
 
-  it("should not be able to fish the same user twice", async () => {
+  it.skip("should not be able to fish the same user twice", async () => {
     let error = await ubi
       .connect(fisherman)
       .fish(claimer.address)
@@ -265,7 +265,7 @@ describe("UBIScheme - network e2e tests", () => {
     expect(error.message).to.have.string("can't fish");
   });
 
-  it("should recieves a claim reward when call claim after being fished", async () => {
+  it.skip("should recieves a claim reward when call claim after being fished", async () => {
     let activeUsersCountBefore = await ubi.activeUsersCount();
     let claimerBalanceBefore = await goodDollar.balanceOf(claimer.address);
     await ubi.connect(claimer).claim();
@@ -279,7 +279,7 @@ describe("UBIScheme - network e2e tests", () => {
     ).to.be.equal(1000);
   });
 
-  it("should be able to fish by calling fishMulti", async () => {
+  it.skip("should be able to fish by calling fishMulti", async () => {
     await increaseTime(MAX_INACTIVE_DAYS * 86700);
     let amount = 1e8;
     await dai["mint(address,uint256)"](

package/test/ubi/UBISchemeCycle.test.ts

@@ -13,10 +13,19 @@ const ONE_DAY = 86400;
 describe("UBIScheme cycle", () => {
   let goodDollar, firstClaimPool;
   let reputation;
-  let root, acct, claimer1, claimer2, claimer3, signers, nameService, genericCall, ubiScheme: UBIScheme;
+  let root,
+    acct,
+    claimer1,
+    claimer2,
+    claimer3,
+    signers,
+    nameService,
+    genericCall,
+    ubiScheme: UBIScheme;
 
   before(async () => {
-    [root, acct, claimer1, claimer2, claimer3, ...signers] = await ethers.getSigners();
+    [root, acct, claimer1, claimer2, claimer3, ...signers] =
+      await ethers.getSigners();
 
     const deployedDAO = await loadFixture(createDAO);
     let {
@@ -55,7 +64,9 @@ describe("UBIScheme cycle", () => {
 
   it("should be able to change cycleLength if avatar", async () => {
     // initializing the ubi
-    let encodedCall = ubiScheme.interface.encodeFunctionData("setCycleLength", [8]);
+    let encodedCall = ubiScheme.interface.encodeFunctionData("setCycleLength", [
+      8
+    ]);
     await genericCall(ubiScheme.address, encodedCall);
     expect(await ubiScheme.cycleLength()).to.be.equal(8);
   });
@@ -70,7 +81,10 @@ describe("UBIScheme cycle", () => {
 
   it("should set ubischeme", async () => {
     // initializing the ubi
-    let encodedCall = firstClaimPool.interface.encodeFunctionData("setUBIScheme", [ubiScheme.address]);
+    let encodedCall = firstClaimPool.interface.encodeFunctionData(
+      "setUBIScheme",
+      [ubiScheme.address]
+    );
 
     await genericCall(firstClaimPool.address, encodedCall);
     // await firstClaimPool.start();
@@ -78,13 +92,21 @@ describe("UBIScheme cycle", () => {
 
   it("should calculate cycle on first day", async () => {
     await increaseTime(2 * ONE_DAY); //make sure
+
+    let balance = await goodDollar.balanceOf(ubiScheme.address);
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait();
-    await ubiScheme.connect(claimer2).claim();
     let cycleLength = await ubiScheme.cycleLength();
     let currentCycle = await ubiScheme.currentCycleLength();
-    let balance = await goodDollar.balanceOf(ubiScheme.address);
+    let dailyAmount = await ubiScheme.dailyUbi();
     expect(currentCycle.toNumber()).to.be.gt(0);
-    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
+    const cycleEvent = transaction.events.find(
+      e => e.event === "UBICycleCalculated"
+    );
+    console.log({
+      dailyAmount: dailyAmount.toString(),
+      event: cycleEvent.args
+    });
+
     expect(cycleEvent.args.day.toNumber()).to.be.a("number");
     expect(cycleEvent.args.pool).to.be.equal(balance);
     expect(cycleEvent.args.cycleLength).to.be.equal(cycleLength);
@@ -92,35 +114,53 @@ describe("UBIScheme cycle", () => {
   });
 
   it("should  have calculated dailyCyclePool and dailyUbi correctly", async () => {
+    await ubiScheme.connect(claimer2).claim();
     increaseTime(ONE_DAY);
     let transaction = await ubiScheme.connect(claimer2).claim();
-    expect(await goodDollar.balanceOf(claimer2.address).then(_ => _.toNumber())).to.be.equal(
-      1000 + (await ubiScheme.dailyUbi().then(_ => _.toNumber()))
-    ); //first day 10G$ (1000 wei), second claim 125000 wei daily pool divided by 2 active users = 625000
-    expect(await ubiScheme.dailyCyclePool().then(_ => _.toNumber())).to.be.equal(125000);
-    expect(await ubiScheme.currentDayInCycle().then(_ => _.toNumber())).to.be.equal(1); //1 day passed
+    expect(
+      await goodDollar.balanceOf(claimer2.address).then(_ => _.toNumber())
+    ).to.be.equal(125 + (await ubiScheme.dailyUbi().then(_ => _.toNumber()))); //first day 125 , second claim 125000 wei daily pool divided by 1000 active users = 125
+    expect(
+      await ubiScheme.dailyCyclePool().then(_ => _.toNumber())
+    ).to.be.equal(125000);
+    expect(
+      await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
+    ).to.be.equal(1); //1 day passed
   });
 
   it("should calculate next cycle even if day passed without claims(setDay)", async () => {
     increaseTime(ONE_DAY * 9);
-    expect(await ubiScheme.currentDayInCycle().then(_ => _.toNumber())).to.be.equal(10); //10 days passed total
+    expect(
+      await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
+    ).to.be.equal(10); //10 days passed total
 
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait(); //claims in new ubi cycle
     let dailyClaimAmount = (await ubiScheme.dailyCyclePool()).div(1000); //initialy we have by default min 1000 active users
 
-    expect(await goodDollar.balanceOf(claimer1.address)).to.be.equal(dailyClaimAmount.add(1000)); //intial 10 from first claim pool + daily
-    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
+    expect(await goodDollar.balanceOf(claimer1.address)).to.be.equal(
+      dailyClaimAmount.add(125)
+    ); //intial 10 from first claim pool + daily
+    const cycleEvent = transaction.events.find(
+      e => e.event === "UBICycleCalculated"
+    );
 
     expect(cycleEvent).to.be.not.empty;
 
-    expect(await ubiScheme.currentDayInCycle().then(_ => _.toNumber())).to.be.equal(0); //new cycle started
-    //intial balance on cycle start 1000000 - 125(one user that claimed) = 999875, divide by cycle length (8) = 124984
-    expect(cycleEvent.args.dailyUBIPool).to.be.equal(124984);
+    expect(
+      await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
+    ).to.be.equal(0); //new cycle started
+    //intial balance on cycle start 1000000 - 375(3 user that claimed in previous tests) = 99625, divide by cycle length (8) = 124953
+    expect(cycleEvent.args.dailyUBIPool).to.be.equal(
+      (BigInt(1000000) - BigInt(375)) / BigInt(8)
+    );
   });
 
   it("should calculate cycle early if we can increase current daily pool", async () => {
     //increase ubi pool balance
-    let encoded = goodDollar.interface.encodeFunctionData("mint", [ubiScheme.address, 400000]);
+    let encoded = goodDollar.interface.encodeFunctionData("mint", [
+      ubiScheme.address,
+      400000
+    ]);
     await genericCall(goodDollar.address, encoded);
     let balance = await goodDollar.balanceOf(ubiScheme.address);
 
@@ -133,7 +173,9 @@ describe("UBIScheme cycle", () => {
     const estimated = await ubiScheme.estimateNextDailyUBI();
     await increaseTime(ONE_DAY); //make sure
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait();
-    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
+    const cycleEvent = transaction.events.find(
+      e => e.event === "UBICycleCalculated"
+    );
     const dailyUBI = await ubiScheme.dailyUbi();
     expect(dailyUBI).to.eq(estimated); //the estimated before actual calculation should be correct, ie equal to actual dailyUBI calculated after first claim.
     expect(cycleEvent).to.be.not.empty;
@@ -145,7 +187,10 @@ describe("UBIScheme cycle", () => {
 
   it("should not calculate cycle early if not possible to increase daily ubi pool", async () => {
     //increase ubi pool balance
-    let encoded = goodDollar.interface.encodeFunctionData("mint", [ubiScheme.address, 100]);
+    let encoded = goodDollar.interface.encodeFunctionData("mint", [
+      ubiScheme.address,
+      100
+    ]);
     await genericCall(goodDollar.address, encoded);
     let balance = await goodDollar.balanceOf(ubiScheme.address);
     const curCycleLen = await ubiScheme.cycleLength();
@@ -155,7 +200,9 @@ describe("UBIScheme cycle", () => {
 
     await increaseTime(ONE_DAY); //make sure
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait();
-    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
+    const cycleEvent = transaction.events.find(
+      e => e.event === "UBICycleCalculated"
+    );
     expect(cycleEvent).to.be.undefined;
   });
 });