@gooddollar/goodprotocol 1.0.25 → 1.0.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "description": "GoodDollar Protocol",
   "scripts": {
     "build": "scripts/build.sh deploy",
@@ -14,10 +14,10 @@
     "daoUpgrade": "hardhat run scripts/upgradeToV2/upgradeToV2.ts",
     "deployOldDAO": "hardhat run scripts/test/localOldDaoDeploy.ts",
     "runNode": "hardhat node &",
-    "testDAOUpgrade": "yarn runNode && yarn compile && yarn deployOldDAO --network develop-mainnet && yarn daoUpgrade --network develop-mainnet",
-    "testDAOUpgradeFuse": "yarn runNode && yarn compile && yarn deployOldDAO --network develop && yarn daoUpgrade --network develop",
-    "deployTestOld": "yarn runNode && yarn compile && hardhat run scripts/test/singleOldDaoDeploy.ts --network dapptest && yarn daoUpgrade --network dapptest && yarn daoUpgrade --network dapptest-mainnet && hardhat run scripts/test/simulateInterest.ts --network dapptest",
-    "deployTest": "yarn runNode && yarn compile && hardhat run scripts/deployFullDAO.ts --network dapptest && hardhat run scripts/deployFullDAO.ts --network dapptest-mainnet && hardhat run scripts/test/simulateInterest.ts --network dapptest"
+    "testDAOUpgrade": "yarn runNode & yarn compile && yarn deployOldDAO --network develop-mainnet && yarn daoUpgrade --network develop-mainnet",
+    "testDAOUpgradeFuse": "yarn runNode & yarn compile && yarn deployOldDAO --network develop && yarn daoUpgrade --network develop",
+    "deployTestOld": "yarn runNode & yarn compile && hardhat run scripts/test/singleOldDaoDeploy.ts --network dapptest && yarn daoUpgrade --network dapptest && yarn daoUpgrade --network dapptest-mainnet && hardhat run scripts/test/simulateInterest.ts --network dapptest",
+    "deployTest": "yarn runNode & yarn compile && hardhat run scripts/deployFullDAO.ts --network dapptest && hardhat run scripts/deployFullDAO.ts --network dapptest-mainnet && hardhat run scripts/test/simulateInterest.ts --network dapptest"
   },
   "files": [
     "artifacts/contracts",
@@ -59,7 +59,7 @@
     "@jsier/retrier": "^1.2.4",
     "@openzeppelin/contracts": "^4.5.0",
     "@openzeppelin/contracts-upgradeable": "^4.3.2",
-    "@typechain/hardhat": "^2.2.0",
+    "@typechain/hardhat": "^6.1.2",
     "async-promise-pool": "^1.0.4",
     "ethers-multicall": "^0.2.1",
     "openzeppelin-solidity": "^4.3.2",
@@ -73,10 +73,10 @@
     "@babel/polyfill": "*",
     "@babel/preset-env": "*",
     "@babel/register": "*",
-    "@nomiclabs/hardhat-ethers": "^2.0.5",
-    "@nomiclabs/hardhat-etherscan": "^3.0.3",
+    "@nomiclabs/hardhat-ethers": "^2.1.1",
+    "@nomiclabs/hardhat-etherscan": "^3.1.0",
     "@nomiclabs/hardhat-waffle": "^2.0.3",
-    "@openzeppelin/hardhat-upgrades": "1.7.0",
+    "@openzeppelin/hardhat-upgrades": "^1.20.0",
     "@typechain/ethers-v5": "^8.0.2",
     "@types/mocha": "*",
     "@types/node": "*",
@@ -93,9 +93,9 @@
     "fs-extra": "9.0.0",
     "graphql": "^15.5.0",
     "graphql-request": "^3.4.0",
-    "hardhat": "^2.9.3",
-    "hardhat-contract-sizer": "^2.0.3",
-    "hardhat-gas-reporter": "^1.0.4",
+    "hardhat": "^2.10.2",
+    "hardhat-contract-sizer": "^2.6.1",
+    "hardhat-gas-reporter": "^1.0.8",
     "lodash": "^4.17.21",
     "merkle-tree-solidity": "*",
     "mocha": "^9.1.2",

package/scripts/bulkProof.ts

@@ -1,7 +1,6 @@
 import fs from "fs";
 import { chunk } from "lodash";
 import { ethers, upgrades, network } from "hardhat";
-import { networkNames } from "@openzeppelin/upgrades-core";
 import GReputationABI from "../artifacts/contracts/governance/GReputation.sol/GReputation.json";
 import BulkProofABI from "../artifacts/contracts/utils/BulkProof.sol/BulkProof.json";
 
@@ -12,14 +11,10 @@ import MerkleTree, {
 import { BigNumber } from "ethers";
 
 console.log({
-  networkNames,
   network: network.name,
   upgrade: process.env.UPGRADE
 });
 const { name: networkName } = network;
-networkNames[1] = networkName;
-networkNames[122] = networkName;
-networkNames[3] = networkName;
 
 export const bulkProof = async () => {
   console.log("signer", await ethers.getSigners());

package/scripts/misc/faucetStats.ts

@@ -0,0 +1,103 @@
+import { range, sortBy, toPairs } from "lodash";
+import fetch from "node-fetch";
+import PromisePool from "async-promise-pool";
+import fs from "fs";
+import { ethers } from "hardhat";
+import { start } from "repl";
+import { JsonRpcProvider } from "@ethersproject/providers";
+import { off } from "process";
+
+function arrayToCsv(data) {
+  return data
+    .map(
+      row =>
+        row
+          .map(String) // convert every value to String
+          .map(v => v.replaceAll('"', '""')) // escape double colons
+          .map(v => `"${v}"`) // quote it
+          .join(",") // comma-separated
+    )
+    .join("\r\n"); // rows starting on new lines
+}
+
+const main = async () => {
+  const archive = new JsonRpcProvider("https://explorer-node.fuse.io");
+  const blockStep = 10000;
+  const pool = new PromisePool({ concurrency: 10 });
+
+  let faucet = await ethers.getContractAt(
+    ["event WalletTopped(address indexed user, uint256 amount)"],
+    "0x01ab5966C1d742Ae0CFF7f14cC0F4D85156e83d9"
+  );
+  const endBlock = Number(await ethers.provider.getBlockNumber());
+  const daysBack = 30;
+  const dayBlocks = 12 * 60 * 24;
+  const startBlock = endBlock - dayBlocks * daysBack;
+  const days = range(startBlock, endBlock, dayBlocks);
+  const dailyBalance = [];
+  for (let day of days) {
+    dailyBalance.push(
+      (
+        await archive.getBalance(
+          "0x01ab5966C1d742Ae0CFF7f14cC0F4D85156e83d9",
+          day
+        )
+      )
+        .div(1e10)
+        .toNumber() / 1e8
+    );
+  }
+  let curBlock = startBlock;
+
+  const toppingsByAddress = {};
+  const toppingsByAmount = {};
+  let totalToppings = 0;
+  let totalAmount = 0;
+  console.log({ dailyBalance });
+  console.log({ startBlock, endBlock });
+  while (curBlock <= endBlock) {
+    const fromBlock = curBlock;
+    const toBlock = Math.min(fromBlock + blockStep, endBlock);
+    pool.add(async () => {
+      const f = faucet.filters.WalletTopped();
+      const events = await faucet
+        .queryFilter(f, fromBlock, toBlock)
+        .catch(e => {
+          console.log("failed", { fromBlock, toBlock });
+          return [];
+        });
+      events.forEach(e => {
+        totalToppings += 1;
+        totalAmount += Number(e.args.amount);
+        toppingsByAddress[e.args.user] =
+          (toppingsByAddress[e.args.user] || 0) + 1;
+        toppingsByAmount[e.args.amount] =
+          (toppingsByAmount[e.args.amount] || 0) + 1;
+      });
+      console.log("fetched events", {
+        fromBlock,
+        toBlock,
+        events: events.length
+      });
+    });
+    curBlock += blockStep;
+  }
+  await pool.all();
+
+  const topToppers = sortBy(toPairs(toppingsByAddress), "1").reverse();
+  const topAmounts = sortBy(toPairs(toppingsByAmount), "1").reverse();
+  const totalWallets = topToppers.length;
+
+  const avgToppingsPerWallet = totalToppings / totalWallets;
+  const avgToppingAmount = totalAmount / totalToppings;
+
+  fs.writeFileSync("topToppers.csv", arrayToCsv(topToppers));
+  fs.writeFileSync("topAmounts.csv", arrayToCsv(topAmounts));
+  console.log({
+    totalAmount,
+    totalToppings,
+    avgToppingsPerWallet,
+    avgToppingAmount
+  });
+};
+main().catch(e => console.log(e));

package/scripts/multichain-deploy/basicdao-deploy.ts

@@ -1,5 +1,4 @@
 import { network, ethers, upgrades, run } from "hardhat";
-import { networkNames } from "@openzeppelin/upgrades-core";
 import { isFunction, get, omitBy } from "lodash";
 import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 import pressAnyKey from "press-any-key";

package/scripts/upgradeScheme.ts

@@ -1,14 +1,10 @@
 import { ethers, upgrades, network } from "hardhat";
-import { networkNames } from "@openzeppelin/upgrades-core";
 import { getSettings, releaser } from "../../scripts/getMigrationSettings";
 import { SchemeRegistrar } from "../types";
 import { getFounders } from "./getFounders";
 
-console.log({ networkNames, network: network.name, upgrade: process.env.UPGRADE });
+console.log({ network: network.name, upgrade: process.env.UPGRADE });
 const { name: networkName } = network;
-networkNames[1] = networkName;
-networkNames[122] = networkName;
-networkNames[3] = networkName;
 
 export const proposeUpgradeScheme = async (daoAddresses, schemeAddress) => {
   console.log("proposing conntract upgrade to DAO", {
@@ -47,7 +43,10 @@ export const voteUpgradeScheme = async (network, daoAddresses, proposalId) => {
   );
 
   const founders = await getFounders(network);
-  console.log("voteUpgradeScheme", { absoluteVote: absoluteVote.address, founders });
+  console.log("voteUpgradeScheme", {
+    absoluteVote: absoluteVote.address,
+    founders
+  });
   await Promise.all(
     founders.slice(0, Math.ceil(founders.length / 2)).map(f =>
       absoluteVote
@@ -59,12 +58,8 @@ export const voteUpgradeScheme = async (network, daoAddresses, proposalId) => {
 };
 
 const main = async () => {
-  const {
-    daoAddresses,
-    modelAddresses,
-    upgradableAddresses,
-    founders
-  } = await getSettings(networkName);
+  const { daoAddresses, modelAddresses, upgradableAddresses, founders } =
+    await getSettings(networkName);
 
   // const implementation = "0x7fca2b3e1047291f65c2c914083d970c027f4290";
   // const deployedProxy = upgradableAddresses.FuseStaking;

package/scripts/upgradeToV2/upgradeToV2.ts

@@ -8,7 +8,6 @@
  */
 
 import { network, ethers, upgrades, run } from "hardhat";
-import { networkNames } from "@openzeppelin/upgrades-core";
 import { isFunction, get, omitBy } from "lodash";
 import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 import pressAnyKey from "press-any-key";
@@ -53,7 +52,6 @@ const countTotalGas = async (tx, name) => {
 };
 
 console.log({
-  networkNames,
   network: network.name,
   upgrade: process.env.UPGRADE
 });
@@ -64,12 +62,6 @@ export const main = async (
   isPerformUpgrade = true,
   olddao?
 ): Promise<{ [key: string]: any }> => {
-  if (networkName.startsWith("dapptest") === false) {
-    networkNames[1] = networkName;
-    networkNames[122] = networkName;
-    networkNames[3] = networkName;
-  }
-
   const isProduction = networkName.startsWith("production");
   if (isProduction && networkName.includes("mainnet")) {
     GAS_SETTINGS.gasLimit = 6000000;
@@ -88,8 +80,8 @@ export const main = async (
     };
   }
 
-  const isBackendTest = networkName.startsWith("dapptest");
-  const isTest = network.name === "hardhat" || isBackendTest;
+  const isDappTest = networkName.startsWith("dapptest");
+  const isTest = network.name === "hardhat" || isDappTest;
   const isCoverage = process.env.CODE_COVERAGE;
   const isDevelop = !isProduction;
   const isMainnet = networkName.includes("mainnet");
@@ -99,7 +91,7 @@ export const main = async (
   };
   console.log(`networkName ${networkName}`, {
     isTest,
-    isBackendTest,
+    isDappTest,
     isCoverage,
     isMainnet,
     isDevelop
@@ -843,14 +835,30 @@ export const main = async (
     //   Promise.resolve(["0x9999c40c8b88c740076b15d2e708db6a7a071b53", 13888])
     // ];
     let deployed;
-    if (!isRopsten || isTest) {
+    if (!isDappTest && (!isRopsten || isTest)) {
       const aaveps = aaveTokens.map(async token => {
         let rewardsPerBlock = (protocolSettings.staking.rewardsPerBlock / 2) //aave gets half of the rewards
           .toFixed(0);
-        console.log("deployStakingContracts", {
+        console.log("deployStakingContracts aave", {
           token,
           settings: protocolSettings.staking,
-          rewardsPerBlock
+          rewardsPerBlock,
+          params: [
+            token.address,
+            get(protocolSettings, "aave.lendingPool", dao.AaveLendingPool),
+            release.NameService,
+            protocolSettings.staking.fullRewardsThreshold, //blocks before switching for 0.5x rewards to 1x multiplier
+            token.usdOracle,
+
+            get(
+              protocolSettings,
+              "aave.incentiveController",
+              dao.AaveIncentiveController
+            ),
+            token.aaveUsdOracle,
+            token.swapPath,
+            GAS_SETTINGS
+          ]
         });
         const tx = await (
           await aavefactory[
@@ -861,7 +869,6 @@ export const main = async (
             release.NameService,
             protocolSettings.staking.fullRewardsThreshold, //blocks before switching for 0.5x rewards to 1x multiplier
             token.usdOracle,
-
             get(
               protocolSettings,
               "aave.incentiveController",

package/scripts/upgradeToV2/upgradeToV2Recover.ts

@@ -8,7 +8,6 @@
  */
 
 import { network, ethers, upgrades, run } from "hardhat";
-import { networkNames } from "@openzeppelin/upgrades-core";
 import { isFunction, get, omitBy } from "lodash";
 import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 
@@ -53,7 +52,6 @@ const countTotalGas = async (tx, name) => {
 };
 
 console.log({
-  networkNames,
   network: network.name,
   upgrade: process.env.UPGRADE
 });
@@ -64,12 +62,6 @@ export const main = async (
   isPerformUpgrade = true,
   olddao?
 ): Promise<{ [key: string]: any }> => {
-  if (networkName.startsWith("dapptest") === false) {
-    networkNames[1] = networkName;
-    networkNames[122] = networkName;
-    networkNames[3] = networkName;
-  }
-
   const isProduction = networkName.startsWith("production");
   if (isProduction && networkName.includes("mainnet")) {
     GAS_SETTINGS.gasLimit = 6000000;

package/test/FuseFaucet.test.ts

@@ -0,0 +1,168 @@
+import hre, { ethers, upgrades } from "hardhat";
+import { expect } from "chai";
+import { FuseFaucet, IGoodDollar, IIdentity } from "../types";
+import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
+import { createDAO } from "./helpers";
+
+const BN = ethers.BigNumber;
+
+describe("FuseFaucet", () => {
+  let faucet: FuseFaucet, founder: SignerWithAddress;
+  let user1 = ethers.Wallet.createRandom().connect(ethers.provider);
+  let user2 = ethers.Wallet.createRandom().connect(ethers.provider);
+  let signers;
+
+  let avatar, gd: IGoodDollar, Controller, id: IIdentity;
+
+  before(async () => {
+    [founder, ...signers] = await ethers.getSigners();
+
+    const FuseFaucetF = await ethers.getContractFactory("FuseFaucet");
+
+    let {
+      daoCreator,
+      controller,
+      avatar: av,
+      gd: gooddollar,
+      identity
+    } = await createDAO();
+
+    Controller = controller;
+    avatar = av;
+
+    // await daoCreator.setSchemes(
+    //   avatar,
+    //   [identity],
+    //   [ethers.constants.HashZero],
+    //   ["0x0000001F"],
+    //   ""
+    // );
+
+    faucet = (await upgrades.deployProxy(FuseFaucetF, [identity], {
+      kind: "transparent"
+    })) as FuseFaucet;
+
+    gd = (await ethers.getContractAt(
+      "IGoodDollar",
+      gooddollar,
+      founder
+    )) as IGoodDollar;
+    id = (await ethers.getContractAt(
+      "IIdentity",
+      identity,
+      founder
+    )) as IIdentity;
+
+    await founder.sendTransaction({
+      value: ethers.utils.parseEther("1"),
+      to: faucet.address
+    });
+  });
+
+  it("should have balance", async () => {
+    const balance = await ethers.provider.getBalance(faucet.address);
+    expect(balance).to.equal(ethers.utils.parseEther("1"));
+  });
+
+  it("should let new user top once", async () => {
+    expect(await faucet.canTop(user1.address)).to.true;
+    const tx = await (await faucet.topWallet(user1.address)).wait();
+    const balance = await ethers.provider.getBalance(user1.address);
+    expect(balance).to.equal(await faucet.toppingAmount());
+  });
+
+  it("should not let new user top more than once", async () => {
+    await user1.sendTransaction({
+      to: ethers.constants.AddressZero,
+      value: ethers.utils.parseUnits("400000", "gwei")
+    });
+    expect(await faucet.canTop(user1.address)).to.false;
+    await expect(faucet.topWallet(user1.address)).to.revertedWith(
+      "User not whitelisted or not first time"
+    );
+  });
+
+  it("should not refund gas when reverted", async () => {
+    const balance = await ethers.provider.getBalance(founder.address);
+    const faucetBalance = await ethers.provider.getBalance(faucet.address);
+    expect(await faucet.canTop(user1.address)).to.false;
+    await expect(faucet.topWallet(user1.address)).to.revertedWith(
+      "User not whitelisted or not first time"
+    );
+    const balanceAfter = await ethers.provider.getBalance(founder.address);
+    const faucetBalanceAfter = await ethers.provider.getBalance(faucet.address);
+    expect(faucetBalanceAfter).to.eq(faucetBalance);
+    expect(balanceAfter).to.lt(balance);
+  });
+
+  it("should let user top again once identified", async () => {
+    await id.addWhitelistedWithDID(user1.address, "did:1");
+    expect(await faucet.canTop(user1.address)).to.true;
+    const tx = await (await faucet.topWallet(user1.address)).wait();
+    console.log(tx.gasUsed.toString());
+    const balance = await ethers.provider.getBalance(user1.address);
+    expect(balance).to.equal(await faucet.toppingAmount());
+  });
+
+  it("should not let identified user top over daily limit", async () => {
+    await user1.sendTransaction({
+      to: ethers.constants.AddressZero,
+      value: ethers.utils.parseUnits("400000", "gwei")
+    });
+    const tx = await (await faucet.topWallet(user1.address)).wait();
+    await user1.sendTransaction({
+      to: ethers.constants.AddressZero,
+      value: ethers.utils.parseUnits("400000", "gwei")
+    });
+    expect(await faucet.canTop(user1.address)).to.false;
+    await expect(faucet.topWallet(user1.address)).to.revertedWith(
+      "max daily toppings"
+    );
+  });
+
+  // it("should not top if wallet not half empty", async () => {
+  //   expect(await faucet.canTop(founder.address)).to.false;
+  //   await expect(faucet.topWallet(founder.address)).to.revertedWith(
+  //     "User balance above minimum"
+  //   );
+  // });
+
+  it("should not let user top over weekly limit", async () => {
+    for (let i = 0; i < 3; i++) {
+      await ethers.provider.send("evm_increaseTime", [60 * 60 * 24]);
+      await (await faucet.topWallet(user1.address)).wait();
+      await user1.sendTransaction({
+        to: ethers.constants.AddressZero,
+        value: ethers.utils.parseUnits("500000", "gwei")
+      });
+      // await (await faucet.topWallet(user1.address)).wait();
+      // await user1.sendTransaction({
+      //   to: ethers.constants.AddressZero,
+      //   value: ethers.utils.parseUnits("500000", "gwei"),
+      // });
+    }
+    // await (await faucet.topWallet(user1.address)).wait();
+    // await user1.sendTransaction({
+    //   to: ethers.constants.AddressZero,
+    //   value: ethers.utils.parseUnits("500000", "gwei"),
+    // });
+    await ethers.provider.send("evm_increaseTime", [60 * 60 * 24]);
+
+    expect(await faucet.canTop(user1.address)).to.false;
+    await expect(faucet.topWallet(user1.address)).to.revertedWith(
+      "User wallet has been topped too many times this week"
+    );
+  });
+
+  it("should reimburse gas costs", async () => {
+    const balance = await ethers.provider.getBalance(founder.address);
+    const tx = await (
+      await faucet.topWallet(user2.address, { gasPrice: 1e9 })
+    ).wait();
+    // const gasCosts = tx.gasUsed.mul(1e9);
+    // const afterRefund = gasCosts.sub(await faucet["gasRefund()"]());
+    const balanceAfter = await ethers.provider.getBalance(founder.address);
+    const diff = balance.sub(balanceAfter).toNumber();
+    expect(diff).to.lt(10000);
+  });
+});