@gooddollar/goodprotocol 1.0.18 → 1.0.19-beta.2

package/test/ubi/UBIScheme.test.ts

@@ -8,6 +8,7 @@ export const NULL_ADDRESS = "0x0000000000000000000000000000000000000000";
 
 const MAX_INACTIVE_DAYS = 3;
 const ONE_DAY = 86400;
+const ONE_HOUR = 3600;
 
 describe("UBIScheme", () => {
   let goodDollar,
@@ -28,6 +29,7 @@ describe("UBIScheme", () => {
     claimer5,
     claimer6,
     claimer7,
+    claimer8,
     signers,
     fisherman,
     nameService,
@@ -44,6 +46,7 @@ describe("UBIScheme", () => {
       claimer5,
       claimer6,
       claimer7,
+      claimer8,
       fisherman,
       ...signers
     ] = await ethers.getSigners();
@@ -83,6 +86,13 @@ describe("UBIScheme", () => {
     // await increaseTime(60 * 60 * 24);
   });
 
+  async function deployNewUbi() {
+    return await upgrades.deployProxy(
+      await ethers.getContractFactory("UBIScheme"),
+      [nameService.address, firstClaimPool.address, 14]
+    );
+  }
+
   it("should not accept 0 inactive days in the constructor", async () => {
     let ubi1 = await (await ethers.getContractFactory("UBIScheme")).deploy();
 
@@ -115,6 +125,22 @@ describe("UBIScheme", () => {
     expect(error.message).to.have.string("only Avatar");
   });
 
+  it("should return zero entitlement before UBI started", async () => {
+    let blockTimestamp = (await ethers.provider.getBlock("latest")).timestamp;
+    const timeInDay = (blockTimestamp % (ONE_DAY));
+    // Move to before 12pm of the current day
+    if (timeInDay > 12 * ONE_HOUR) {
+      blockTimestamp += 12 * ONE_HOUR;
+      await ethers.provider.send("evm_setNextBlockTimestamp", [
+        blockTimestamp
+      ]);
+      await ethers.provider.send("evm_mine", []);
+    }
+    const ubiNew = await deployNewUbi();
+    let amount = await ubiNew.connect(claimer1)["checkEntitlement()"]();
+    expect(amount).to.equal(0);
+  });
+
   it("should start the ubi", async () => {
     await setSchemes([ubi.address]);
     // await ubi.start();
@@ -174,6 +200,27 @@ describe("UBIScheme", () => {
     expect(error.message).to.have.string("Only UBIScheme can call this method");
   });
 
+  it("should estimate next daily UBI to default value when no claimers and not using first claim pool", async () => {
+    const nextDailyUBIBefore = await ubi.estimateNextDailyUBI();
+    const defaultDailyUbi = await ubi.defaultDailyUbi();
+    let encodedCall = ubi.interface.encodeFunctionData(
+      "setUseFirstClaimPool",
+      [false]
+    );
+    await genericCall(ubi.address, encodedCall);
+    const nextDailyUBIAfter = await ubi.estimateNextDailyUBI();
+
+    expect(nextDailyUBIBefore.eq(0));
+    expect(nextDailyUBIAfter.gt(nextDailyUBIBefore));
+    expect(nextDailyUBIAfter.eq(defaultDailyUbi));
+
+    encodedCall = ubi.interface.encodeFunctionData(
+      "setUseFirstClaimPool",
+      [true]
+    );
+    await genericCall(ubi.address, encodedCall);
+  });
+
   it("should award a new user with 0 on first time execute claim if the first claim contract has no balance", async () => {
     let tx = await (await ubi.connect(claimer1).claim()).wait();
     let claimer1Balance = await goodDollar.balanceOf(claimer1.address);
@@ -189,8 +236,11 @@ describe("UBIScheme", () => {
     let transaction = await (await ubi.connect(claimer2).claim()).wait();
     let activeUsersCount = await ubi.activeUsersCount();
     let claimer2Balance = await goodDollar.balanceOf(claimer2.address);
+    const [claimersCount, amountClaimed] = await ubi.getDailyStats();
     expect(claimer2Balance.toNumber()).to.be.equal(100);
+    expect(amountClaimed.eq(100));
     expect(activeUsersCount.toNumber()).to.be.equal(2);
+    expect(claimersCount.eq(2));
     expect(transaction.events.find(_ => _.event === "ActivatedUser")).to.be.not
       .empty;
   });
@@ -574,4 +624,22 @@ describe("UBIScheme", () => {
     const shouldWithdrawFromDAO = await ubi.shouldWithdrawFromDAO();
     expect(shouldWithdrawFromDAO).to.be.equal(false);
   });
+
+  it("should award first claimer with default value when not using first claim pool", async () => {
+    const ubiNew = await deployNewUbi();
+    const defaultDailyUbi = await ubiNew.defaultDailyUbi();
+    await goodDollar.mint(ubiNew.address, defaultDailyUbi);
+    await addWhitelisted(claimer8.address, "claimer8");
+    const encodedCall = ubiNew.interface.encodeFunctionData(
+      "setUseFirstClaimPool",
+      [false]
+    );
+    await genericCall(ubiNew.address, encodedCall);
+    const claimerBalanceBefore = await goodDollar.balanceOf(claimer8.address);
+    await (await ubiNew.connect(claimer8).claim()).wait();
+    const claimerBalanceAfter = await goodDollar.balanceOf(claimer8.address);
+    
+    expect(claimerBalanceAfter.gt(claimerBalanceBefore));
+    expect(claimerBalanceAfter.sub(claimerBalanceBefore).eq(defaultDailyUbi));
+  });
 });

package/test/utils/DAOUpgradeableContract.test.ts

@@ -0,0 +1,47 @@
+import { expect } from "chai";
+import { ethers, upgrades } from "hardhat";
+import { createDAO } from "../helpers";
+
+describe("DAOUpgradeableContract", () => {
+  let signers, avatar, genericCall, controller, nameService;
+  before(async () => {
+    signers = await ethers.getSigners();
+
+    let {
+      controller: ctrl,
+      avatar: av,
+      genericCall: gc,
+      nameService: ns
+    } = await createDAO();
+
+    avatar = av;
+    genericCall = gc;
+    controller = ctrl;
+    nameService = ns;
+  });
+
+  it("should be able to authorize upgrade for dao upgradable contract", async () => {
+    const upgradableMockFactory = await ethers.getContractFactory(
+      "UpgradableMock3"
+    );
+    
+    const daoUpgradableProxy = await upgrades.deployProxy(
+      upgradableMockFactory,
+      [nameService.address],
+      { kind: "uups" }
+    );
+    const differentUpgradableMock = await (
+      await ethers.getContractFactory("UpgradableMock4")
+    ).deploy();
+    const secondContractDecimals = await differentUpgradableMock.decimals();
+    const decimalsBeforeUpgrade = await daoUpgradableProxy.decimals();
+    const encodedData = daoUpgradableProxy.interface.encodeFunctionData(
+      "upgradeTo",
+      [differentUpgradableMock.address]
+    );
+    await (await genericCall(daoUpgradableProxy.address, encodedData)).wait();
+    const decimalsAfterUpgrade = await daoUpgradableProxy.decimals();
+    expect(decimalsBeforeUpgrade).to.not.eq(decimalsAfterUpgrade);
+    expect(decimalsAfterUpgrade).to.eq(secondContractDecimals);
+  });
+});

package/test/utils/NameService.test.ts

@@ -1,27 +1,15 @@
-import { default as hre, ethers, upgrades } from "hardhat";
-import { BigNumber, Contract, Signer } from "ethers";
-import { deployMockContract, MockContract } from "ethereum-waffle";
 import { expect } from "chai";
-import {
-  GoodMarketMaker,
-  CERC20,
-  GoodReserveCDai,
-  UniswapFactory
-} from "../../types";
-import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
-import { createDAO, increaseTime, advanceBlocks } from "../helpers";
-import ContributionCalculation from "@gooddollar/goodcontracts/stakingModel/build/contracts/ContributionCalculation.json";
-import { parseUnits } from "@ethersproject/units";
-import ERC20 from "@uniswap/v2-core/build/ERC20.json";
-import WETH9 from "@uniswap/v2-periphery/build/WETH9.json";
-import UniswapV2Router02 from "@uniswap/v2-periphery/build/UniswapV2Router02.json";
+import { ethers, upgrades, network } from 'hardhat';
+import { createDAO } from "../helpers";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 
 const BN = ethers.BigNumber;
 export const NULL_ADDRESS = ethers.constants.AddressZero;
 export const BLOCK_INTERVAL = 1;
 
 describe("NameService - Setup and functionalities", () => {
-  let nameService, dai, avatar, controller, schemeMock, signers;
+  let nameService, dai, avatar, controller, schemeMock, signers, genericCall, 
+    runAsAvatarOnly;
 
   before(async () => {
     signers = await ethers.getSigners();
@@ -39,12 +27,16 @@ describe("NameService - Setup and functionalities", () => {
       nameService: ns,
       setDAOAddress: sda,
       setSchemes,
-      marketMaker: mm
+      marketMaker: mm,
+      genericCall: gc,
+      runAsAvatarOnly: raao,
     } = await createDAO();
 
     controller = ctrl;
     avatar = av;
     nameService = ns;
+    genericCall = gc;
+    runAsAvatarOnly = raao;
     console.log("deployed dao", {
       gd,
       identity,
@@ -55,61 +47,64 @@ describe("NameService - Setup and functionalities", () => {
     await setSchemes([schemeMock.address]);
   });
 
-  it(" address should not be set  ", async () => {
-    await expect(nameService.setAddress("DAI", dai.address)).to.be.revertedWith(
-      "only avatar can call this method"
-    );
-  });
-
-  it(" addresses should not be set  ", async () => {
-    await expect(
-      nameService.setAddresses(
-        [
-          ethers.utils.formatBytes32String("DAI"),
-          ethers.utils.formatBytes32String("cDAI")
-        ],
-        [(signers[0].address, signers[1].address)]
-      )
-    ).to.be.revertedWith("only avatar can call this method");
-  });
-
   it("should set address by avatar", async () => {
-    const nsFactory = await ethers.getContractFactory("NameService");
-    const encoded = nsFactory.interface.encodeFunctionData("setAddress", [
+    await runAsAvatarOnly(
+      nameService,
+      "setAddress(string,address)",
       "DAI",
       dai.address
-    ]);
-
-    const ictrl = await ethers.getContractAt(
-      "Controller",
-      controller,
-      schemeMock
     );
-
-    await ictrl.genericCall(nameService.address, encoded, avatar, 0);
     expect(await nameService.getAddress("DAI")).to.be.equal(dai.address);
   });
 
   it("should set multiple addresses by avatar", async () => {
-    const nsFactory = await ethers.getContractFactory("NameService");
-    const encoded = nsFactory.interface.encodeFunctionData("setAddresses", [
+    await runAsAvatarOnly(
+      nameService,
+      "setAddresses(bytes32[],address[])", 
       [
         ethers.utils.keccak256(ethers.utils.toUtf8Bytes("DAI")),
         ethers.utils.keccak256(ethers.utils.toUtf8Bytes("cDAI"))
       ],
       [signers[0].address, signers[1].address]
-    ]);
-
-    const ictrl = await ethers.getContractAt(
-      "Controller",
-      controller,
-      schemeMock
     );
 
-    await ictrl.genericCall(nameService.address, encoded, avatar, 0);
     expect(await nameService.getAddress("DAI")).to.be.equal(signers[0].address);
     expect(await nameService.getAddress("cDAI")).to.be.equal(
       signers[1].address
     );
   });
+
+  it("should authorize upgrade only for avatar", async () => {
+    const nameServiceProxy = await upgrades.deployProxy(
+      await ethers.getContractFactory("NameService"),
+      [
+        controller,
+        [
+          "CONTROLLER",
+        ].map(_ => ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))),
+        [
+          controller
+        ]
+      ],
+      {
+        kind: "uups"
+      }
+    );
+    const implementationBeforeUpgrade =
+      await getImplementationAddress(network.provider, nameServiceProxy.address);
+    const newNameServiceLogic = await (await ethers.getContractFactory("NameService")).deploy();
+    const encodedData = nameServiceProxy.interface.encodeFunctionData(
+      "upgradeTo",
+      [newNameServiceLogic.address]
+    );
+    await (await genericCall(nameServiceProxy.address, encodedData)).wait();
+    const implementationAfterUpgrade =
+      await getImplementationAddress(network.provider, nameServiceProxy.address);
+    expect(implementationBeforeUpgrade).to.not.equal(implementationAfterUpgrade);
+    expect(implementationAfterUpgrade).to.equal(newNameServiceLogic.address);
+
+    const newNameServiceLogic2 = await (await ethers.getContractFactory("NameService")).deploy();
+    await expect(nameServiceProxy.upgradeTo(newNameServiceLogic2.address)).
+      to.be.revertedWith("only avatar can call this method");
+  });  
 });

package/test/utils/ProxyFactory.test.ts

@@ -130,4 +130,21 @@ describe("proxyfactory", () => {
     let orgproxy = await ethers.getContractAt("UpgradableMock", proxyAddr);
     expect(await orgproxy.owner()).to.eq(signers[2].address);
   });
+
+  it("should use deploy minimal to deploy proxy with impl and initialize it", async () => {
+    const c1 = await (
+      await ethers.getContractFactory("UpgradableMock")
+    ).deploy();
+
+    const encoded = c1.interface.encodeFunctionData("initialize", [
+      signers[2].address
+    ]);
+    const deployTX = await (
+      await factory.deployMinimal(c1.address, encoded)
+    ).wait();
+    const proxyAddr = deployTX.events.find(_ => _.event === "ProxyCreated").args
+      .proxy;
+    proxy = await ethers.getContractAt("UpgradableMock", proxyAddr);
+    expect(await proxy.owner()).to.eq(signers[2].address);
+  });
 });