@gooddollar/goodprotocol 1.0.3-beta.1 → 1.0.3

package/scripts/keeper/fishInactive.ts

@@ -0,0 +1,57 @@
+import { range, chunk } from "lodash";
+import { ethers as Ethers } from "hardhat";
+import fetch from "node-fetch";
+
+const ONE_DAY = 24 * 60 * 60;
+
+const main = async () => {
+  const signer = (await Ethers.getSigners())[0];
+  console.log("signer:", signer.address);
+  const ubiScheme = new Ethers.Contract(
+    "0xD7aC544F8A570C4d8764c3AAbCF6870CBD960D0D",
+    ["function fishMulti(address[] tofish)"]
+  ).connect(signer);
+  const twoWeeksAgo =
+    parseInt((Date.now() / 1000).toFixed(0)) - 24 * 60 * 60 * 14;
+
+  const daysAgo: number[] = range(0, 180, 1);
+  let curDay = twoWeeksAgo;
+  for (let day of daysAgo) {
+    const query = `
+      { 
+        walletStats(first:1000, where: { lastClaimed_lt: ${curDay},lastClaimed_gt: ${
+      curDay - 24 * 60 * 60
+    } isActiveUser: true }) {
+        id        
+      }
+    }
+  `;
+
+    console.log(
+      "fetching inactive users since:",
+      { curDay, day },
+      JSON.stringify({ query })
+    );
+    const { walletStats } = await fetch(
+      "https://api.thegraph.com/subgraphs/name/gooddollar/gooddollarfuse",
+      {
+        method: "post",
+        body: JSON.stringify({ query }),
+        headers: { "Content-Type": "application/json" }
+      }
+    ).then(_ => _.json());
+
+    console.log("got inactive wallets:", walletStats.length);
+    const accounts = walletStats.map(_ => _.id);
+    for (let tofish of chunk(accounts, 50)) {
+      const tx = await ubiScheme.fishMulti(tofish, { gasLimit: 2000000 });
+      console.log("fishing tx:", tx, tofish);
+      const res = await tx.wait();
+      console.log("fishing tx result:", res);
+    }
+
+    curDay = curDay - ONE_DAY;
+  }
+};
+
+main();

package/scripts/upgradeToV2/upgradeToV2.ts

@@ -74,7 +74,7 @@ export const main = async (
   if (isProduction && networkName.includes("mainnet")) {
     GAS_SETTINGS.gasLimit = 6000000;
     GAS_SETTINGS.maxFeePerGas = ethers.utils.parseUnits("80", "gwei");
-  } else if (!networkName.includes("mainnet")) {
+  } else if (network.config.chainId === 122) {
     //case we are on fusefuse
     GAS_SETTINGS = {
       gasLimit: 6000000,
@@ -108,6 +108,10 @@ export const main = async (
 
   const founders = await getFounders(networkName);
 
+  console.log(
+    `root: ${root.address} founders: ${founders.map(_ => _.address)}`
+  );
+
   const compoundTokens = [
     {
       name: "cdai",
@@ -216,7 +220,8 @@ export const main = async (
       args: [
         () => get(release, "NameService", newdao.NameService),
         protocolSettings.governance.proposalVotingPeriod,
-        protocolSettings.governance.guardian || root.address
+        protocolSettings.governance.guardian || root.address,
+        () => get(release, "GReputation", newdao.GReputation)
       ]
     },
     {
@@ -355,6 +360,7 @@ export const main = async (
 
       if (contract.isUpgradable !== false) {
         if (isCoverage) {
+          console.log("Deploying:", contract.name, "using proxy");
           //coverage has large contracts doesnt work with proxy factory
           const tx = await upgrades.deployProxy(Contract, args, {
             initializer: contract.initializer,
@@ -364,6 +370,7 @@ export const main = async (
           await countTotalGas(tx, contract.name);
           return tx;
         }
+        console.log("Deploying:", contract.name, "using proxyfactory");
         const encoded = Contract.interface.encodeFunctionData(
           contract.initializer || "initialize",
           args
@@ -394,6 +401,7 @@ export const main = async (
       } else {
         //for some reason deploying with link library via proxy doesnt work on hardhat test env
         if (isTest === false) {
+          console.log("Deploying:", contract.name, "using proxyfactory code");
           const constructor = Contract.interface.encodeDeploy(args);
           const bytecode = ethers.utils.solidityPack(
             ["bytes", "bytes"],
@@ -411,6 +419,7 @@ export const main = async (
             )
           );
         } else {
+          console.log("Deploying:", contract.name, "using regular");
           const tx = await Contract.deploy(...args, GAS_SETTINGS);
           await countTotalGas(tx, contract.name);
           const impl = await tx.deployed();
@@ -944,7 +953,7 @@ export const main = async (
     !isMainnet && (await performUpgradeFuse(release));
     console.log("upgraded contracts", { totalGas });
   }
-  if (!isTest && !isCoverage) {
+  if (isMainnet && !isTest && !isCoverage) {
     await verifyContracts(release);
   }
 
@@ -952,7 +961,7 @@ export const main = async (
   return release;
   // await proveNewRep();
 };
-if (network.name !== "hardhat") {
+if (network.name !== "hardhat" && process.argv[1].includes("upgradeToV2.ts")) {
   main(name, false)
     .catch(e => {
       console.log(e);

package/test/governance/CompoundVotingMachine.delegate.test.ts

@@ -62,10 +62,6 @@ describe("CompoundVotingMachine#Delegation", () => {
   before(async () => {
     [root, acct, ...signers] = await ethers.getSigners();
 
-    const CompoundVotingMachine = await ethers.getContractFactory(
-      "CompoundVotingMachine"
-    );
-
     let {
       daoCreator,
       reputation,

package/test/governance/CompoundVotingMachine.guardian.test.ts

@@ -93,7 +93,7 @@ describe("CompoundVotingMachine#Guardian", () => {
   it("should set guardian from initializer", async () => {
     const votingMachine = (await upgrades.deployProxy(
       await ethers.getContractFactory("CompoundVotingMachine"),
-      [nameService.address, 5760, signers[2].address],
+      [nameService.address, 5760, signers[2].address, NULL_ADDRESS],
       { kind: "uups" }
     )) as unknown as CompoundVotingMachine;
     expect(await votingMachine.guardian()).to.equal(signers[2].address);
@@ -151,7 +151,7 @@ describe("CompoundVotingMachine#Guardian", () => {
 
     const gov2 = (await upgrades.deployProxy(
       CompoundVotingMachine,
-      [nameService.address, 5760, root.address],
+      [nameService.address, 5760, root.address, NULL_ADDRESS],
       { kind: "uups" }
     )) as CompoundVotingMachine;
 

package/test/helpers.ts

@@ -14,15 +14,8 @@ import IUniswapV2Pair from "@uniswap/v2-core/build/IUniswapV2Pair.json";
 import UniswapV2Factory from "@uniswap/v2-core/build/UniswapV2Factory.json";
 import WETH9 from "@uniswap/v2-periphery/build/WETH9.json";
 import UniswapV2Router02 from "@uniswap/v2-periphery/build/UniswapV2Router02.json";
-import {
-  Controller,
-  GoodMarketMaker,
-  CompoundVotingMachine,
-  GoodCompoundStaking,
-  GoodAaveStaking
-} from "../types";
-import { Contract } from "@ethersproject/contracts";
-import { BigNumber } from "@ethersproject/bignumber";
+import { GoodMarketMaker, CompoundVotingMachine } from "../types";
+import { Contract } from "ethers";
 
 export const getStakingFactory = async (
   factory: "GoodCompoundStaking" | "GoodAaveStaking" | "GoodCompoundStakingTest"
@@ -285,7 +278,7 @@ export const createDAO = async () => {
   );
   const votingMachine = (await upgrades.deployProxy(
     await ethers.getContractFactory("CompoundVotingMachine"),
-    [nameService.address, 5760, root.address],
+    [nameService.address, 5760, root.address, reputation.address],
     { kind: "uups" }
   )) as unknown as CompoundVotingMachine;
   return {

package/test/reserve/GoodReserveCDai.cap.test.ts

@@ -2,7 +2,7 @@ import { default as hre, ethers, upgrades } from "hardhat";
 import { expect } from "chai";
 import { GoodMarketMaker, CERC20, GoodReserveCDai } from "../../types";
 import { createDAO, increaseTime, advanceBlocks } from "../helpers";
-import { Contract } from "@ethersproject/contracts";
+import { Contract } from "ethers";
 
 const BN = ethers.BigNumber;
 export const NULL_ADDRESS = ethers.constants.AddressZero;

package/test/reserve/GoodReserveCDai.test.ts

@@ -175,7 +175,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
   //   // await goodDollar.addMinter(goodReserve.address);
   // });
 
-  xit("should mint UBI correctly for 18 decimals precision and no interest", async () => {
+  it("should mint UBI correctly for 18 decimals precision and no interest", async () => {
     let reserveToken = await marketMaker.reserveTokens(cDAI.address);
     let reserveBalanceBefore = reserveToken.reserveSupply;
     let supplyBefore = reserveToken.gdSupply;
@@ -191,7 +191,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
 
     await dai["mint(address,uint256)"](goodReserve.address, daiAmount);
     const tx = await (
-      await goodReserve.mintUBI(1, ethers.utils.parseEther("0.1"), cDAI.address)
+      await goodReserve.mintUBI(daiAmount, 0, cDAI.address)
     ).wait();
     const gdBalanceFund = await goodDollar.balanceOf(founder.address);
     const gdPriceAfter = await goodReserve["currentPrice()"]();
@@ -214,7 +214,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
     // expected that the new reserve balance will include
     // the new 1e18 cdai which transferred
     expect(reserveBalanceAfter).to.be.equal(
-      reserveBalanceBefore.add(BN.from("10").pow(17)).sub(BN.from("1"))
+      reserveBalanceBefore.add(BN.from("10").pow(17))
     );
     // the new reserve ratio should be effected from the mintExpansion by:
     // the daily change that was set up in the constructor (999388834642296)
@@ -228,115 +228,17 @@ describe("GoodReserve - staking with cDAI mocks", () => {
         .toString()
     );
   });
-  /*
-  it("should mint UBI correctly for 18 decimals precision and partial interest", async () => {
-    let reserveToken = await marketMaker.reserveTokens(cDAI.address);
-    let reserveBalanceBefore = reserveToken.reserveSupply;
-    let supplyBefore = reserveToken.gdSupply;
-    const gdBalanceFundBefore = await goodDollar.balanceOf(founder.address);
-    const gdBalanceAvatarBefore = await goodDollar.balanceOf(avatar);
-    const gdPriceBefore = await goodReserve["currentPrice()"]();
-    const tx = await (
-      await goodReserve.mintInterestAndUBI(
-        cDAI.address,
-        ethers.utils.parseUnits("10000", "gwei"),
-        "10000"
-      )
-    ).wait(); // interest is 0.0001 cDai which equal to 1 gd
-    const gdBalanceFundAfter = await goodDollar.balanceOf(founder.address);
-    const gdBalanceAvatarAfter = await goodDollar.balanceOf(avatar);
-    const gdPriceAfter = await goodReserve["currentPrice()"]();
-    reserveToken = await marketMaker.reserveTokens(cDAI.address);
-    let reserveBalanceAfter = reserveToken.reserveSupply;
-    let supplyAfter = reserveToken.gdSupply;
-    let rrAfter = reserveToken.reserveRatio;
-    let et = BN.from(ethers.utils.parseUnits("10000", "gwei"));
-    console.log(
-      gdPriceBefore.toNumber(),
-      supplyAfter.toNumber(),
-      supplyBefore.toNumber()
-    );
-    const mintEvent = tx.events.find(_ => _.event === "UBIMinted");
-    const toMint = mintEvent.args.gdInterestMinted.add(
-      mintEvent.args.gdExpansionMinted
-    );
-    expect(reserveBalanceAfter.toString()).to.be.equal(
-      et.add(reserveBalanceBefore).toString(),
-      "reserve balance has changed"
-    );
-    expect(supplyAfter.toString()).to.be.equal(
-      toMint.add(supplyBefore).toString(),
-      "supply has changed"
-    );
-    expect(gdPriceAfter.toString()).to.be.equal(
-      gdPriceBefore.toString(),
-      "price has changed"
-    );
-    expect(
-      (gdBalanceAvatarAfter - gdBalanceAvatarBefore).toString()
-    ).to.be.equal("0"); // 1 gd
-    expect(gdBalanceFundAfter.sub(gdBalanceFundBefore)).to.be.equal(
-      toMint,
-      "ubi minted mismatch"
-    );
-    expect(rrAfter.toString()).to.be.equal("999388");
+
+  it("should not mint UBI if the reserve is not cDAI", async () => {
+    let error = await goodReserve.mintUBI(1, 0, dai.address).catch(e => e);
+    expect(error.message).not.to.be.empty;
   });
-  */
-  // it("should not mint UBI if the reserve is not cDAI", async () => {
-  //   let error = await goodReserve
-  //     .mintInterestAndUBI(dai.address, ethers.utils.parseEther("1"), "0")
-  //     .catch(e => e);
-  //   expect(error.message).not.to.be.empty;
-  // });
 
-  xit("should not mint UBI if the caller is not the fund manager", async () => {
-    let tx = goodReserve
-      .connect(staker)
-      .mintUBI(1, ethers.utils.parseEther("1"), cDAI.address);
+  it("should not mint UBI if the caller is not the fund manager", async () => {
+    let tx = goodReserve.connect(staker).mintUBI(0, 0, cDAI.address);
     await expect(tx).to.be.revertedWith("GoodReserve: not a minter");
   });
 
-  // it("should set block interval by avatar", async () => {
-  //   let encodedCall = web3.eth.abi.encodeFunctionCall(
-  //     {
-  //       name: "setBlockInterval",
-  //       type: "function",
-  //       inputs: [
-  //         {
-  //           type: "uint256",
-  //           name: "_blockInterval"
-  //         }
-  //       ]
-  //     },
-  //     [100]
-  //   );
-  //   await controller.genericCall(
-  //     goodReserve.address,
-  //     encodedCall,
-  //     avatar,
-  //     0
-  //   );
-  //   const newBI = await goodReserve.blockInterval();
-  //   expect(newBI.toString()).to.be.equal("100");
-  // });
-
-  // it("should not mint UBI if not in the interval", async () => {
-  //   const gdBalanceFundBefore = await goodDollar.balanceOf(founder.address);
-  //   const gdBalanceAvatarBefore = await goodDollar.balanceOf(avatar);
-  //   const error = await goodReserve
-  //     .mintInterestAndUBI(
-  //       cDAI.address,
-  //       ethers.utils.parseUnits("10000", "gwei"),
-  //       "10000"
-  //     )
-  //     .catch(e => e);
-  //   const gdBalanceFundAfter = await goodDollar.balanceOf(founder.address);
-  //   const gdBalanceAvatarAfter = await goodDollar.balanceOf(avatar);
-  //   expect(error.message).to.have.string("wait for the next interval");
-  //   expect(gdBalanceFundAfter).to.be.equal(gdBalanceFundBefore);
-  //   expect(gdBalanceAvatarAfter).to.be.equal(gdBalanceAvatarBefore);
-  // });
-
   it("should be able to buy gd with DAI", async () => {
     let daiAmount = ethers.utils.parseEther("100");
     const cdaiRateStored = await cDAI.exchangeRateStored();
@@ -1086,8 +988,8 @@ describe("GoodReserve - staking with cDAI mocks", () => {
         (1 - amount.toNumber() / parseInt(supply.toString())) **
           (1000000 / reserveToken.reserveRatio));
 
-    // expected = Math.ceil((0.8 * expected) / 100) * 100; //deduct 20% contribution, allow 2 points precission mismatch (due to bancor pow estimation?), match solidity no floating point
-    expected = Math.floor(0.8 * expected);
+    expected = Math.ceil((0.8 * expected) / 100) * 100; //deduct 20% contribution, allow 5 points precission mismatch (due to bancor pow estimation?), match solidity no floating point
+    //expected = Math.floor(0.8 * expected);
     expect(cDAIBalanceAfter.sub(cDAIBalanceBefore)).to.be.equal(expected);
     expect(cDAIBalanceReserveBefore.sub(cDAIBalanceReserveAfter)).to.be.equal(
       expected

package/test/utils/ProtocolUpgrade.test.ts

@@ -417,6 +417,14 @@ describe("ProtocolUpgrade - Upgrade old protocol contracts to new ones", () => {
     );
   });
 
+  it("should initialize reputation address", async () => {
+    const cvm = await ethers.getContractAt(
+      "CompoundVotingMachine",
+      deployment["test-mainnet"].CompoundVotingMachine
+    );
+    expect(await cvm.rep()).to.equal(deployment["test-mainnet"].GReputation);
+  });
+
   it("it should set fuse nameservice variables properly", async () => {
     const fse = require("fs-extra");
     const deployment = await fse.readJson("releases/deployment.json");