@gooddollar/goodprotocol 1.0.23 → 1.0.26-beta.0

package/patches/@nomiclabs+hardhat-etherscan+3.0.3.patch

@@ -0,0 +1,41 @@
+diff --git a/node_modules/@nomiclabs/hardhat-etherscan/dist/src/ChainConfig.js b/node_modules/@nomiclabs/hardhat-etherscan/dist/src/ChainConfig.js
+index 007d740..139c489 100644
+--- a/node_modules/@nomiclabs/hardhat-etherscan/dist/src/ChainConfig.js
++++ b/node_modules/@nomiclabs/hardhat-etherscan/dist/src/ChainConfig.js
+@@ -10,6 +10,13 @@ exports.chainConfig = {
+             browserURL: "https://etherscan.io",
+         },
+     },
++    celo: {
++        chainId: 42220,
++        urls: {
++            apiURL: "https://api.celoscan.xyz/api",
++            browserURL: "https://celoscan.xyz",
++        },
++    },
+     harmony: {
+         chainId: 1666600000,
+         urls: {
+diff --git a/node_modules/@nomiclabs/hardhat-etherscan/dist/src/types.d.ts b/node_modules/@nomiclabs/hardhat-etherscan/dist/src/types.d.ts
+index 0a9efc3..88bdaac 100644
+--- a/node_modules/@nomiclabs/hardhat-etherscan/dist/src/types.d.ts
++++ b/node_modules/@nomiclabs/hardhat-etherscan/dist/src/types.d.ts
+@@ -1,4 +1,4 @@
+-declare type Chain = "mainnet" | "ropsten" | "rinkeby" | "goerli" | "kovan" | "bsc" | "bscTestnet" | "heco" | "hecoTestnet" | "opera" | "ftmTestnet" | "optimisticEthereum" | "optimisticKovan" | "polygon" | "polygonMumbai" | "arbitrumOne" | "arbitrumTestnet" | "avalanche" | "avalancheFujiTestnet" | "moonbeam" | "moonriver" | "moonbaseAlpha" | "harmony" | "harmonyTest" | "xdai" | "sokol" | "aurora" | "auroraTestnet";
++declare type Chain = "celo" | "mainnet" | "ropsten" | "rinkeby" | "goerli" | "kovan" | "bsc" | "bscTestnet" | "heco" | "hecoTestnet" | "opera" | "ftmTestnet" | "optimisticEthereum" | "optimisticKovan" | "polygon" | "polygonMumbai" | "arbitrumOne" | "arbitrumTestnet" | "avalanche" | "avalancheFujiTestnet" | "moonbeam" | "moonriver" | "moonbaseAlpha" | "harmony" | "harmonyTest" | "xdai" | "sokol" | "aurora" | "auroraTestnet";
+ export declare type ChainConfig = {
+     [Network in Chain]: EtherscanChainConfig;
+ };
+diff --git a/node_modules/@nomiclabs/hardhat-etherscan/src/types.ts b/node_modules/@nomiclabs/hardhat-etherscan/src/types.ts
+index b88e8fa..4c658b2 100644
+--- a/node_modules/@nomiclabs/hardhat-etherscan/src/types.ts
++++ b/node_modules/@nomiclabs/hardhat-etherscan/src/types.ts
+@@ -36,7 +36,7 @@ type Chain =
+   | "sokol"
+   // aurora
+   | "aurora"
+-  | "auroraTestnet";
++  | "auroraTestnet" | "celo";
+ 
+ export type ChainConfig = {
+   [Network in Chain]: EtherscanChainConfig;

package/patches/@openzeppelin+hardhat-upgrades+1.7.0.patch

@@ -0,0 +1,67 @@
+diff --git a/node_modules/@openzeppelin/hardhat-upgrades/dist/deploy-proxy.d.ts b/node_modules/@openzeppelin/hardhat-upgrades/dist/deploy-proxy.d.ts
+index 2405883..5879166 100644
+--- a/node_modules/@openzeppelin/hardhat-upgrades/dist/deploy-proxy.d.ts
++++ b/node_modules/@openzeppelin/hardhat-upgrades/dist/deploy-proxy.d.ts
+@@ -7,6 +7,7 @@ export interface DeployFunction {
+ }
+ export interface DeployOptions extends ValidationOptions {
+     initializer?: string | false;
++    proxyFactory?: any;
+ }
+ export declare function makeDeployProxy(hre: HardhatRuntimeEnvironment): DeployFunction;
+ //# sourceMappingURL=deploy-proxy.d.ts.map
+
+diff --git a/node_modules/@openzeppelin/hardhat-upgrades/dist/deploy-proxy.js b/node_modules/@openzeppelin/hardhat-upgrades/dist/deploy-proxy.js
+index 8dbb62a..d0761f4 100644
+--- a/node_modules/@openzeppelin/hardhat-upgrades/dist/deploy-proxy.js
++++ b/node_modules/@openzeppelin/hardhat-upgrades/dist/deploy-proxy.js
+@@ -26,14 +26,15 @@ function makeDeployProxy(hre) {
+         let proxyDeployment;
+         switch (kind) {
+             case 'uups': {
+-                const ProxyFactory = await utils_1.getProxyFactory(hre, ImplFactory.signer);
++                const ProxyFactory = await (opts.proxyFactory || utils_1.getProxyFactory(hre, ImplFactory.signer))
+                 proxyDeployment = Object.assign({ kind }, await utils_1.deploy(ProxyFactory, impl, data));
+                 break;
+             }
+             case 'transparent': {
+                 const AdminFactory = await utils_1.getProxyAdminFactory(hre, ImplFactory.signer);
+                 const adminAddress = await upgrades_core_1.fetchOrDeployAdmin(provider, () => utils_1.deploy(AdminFactory));
+-                const TransparentUpgradeableProxyFactory = await utils_1.getTransparentUpgradeableProxyFactory(hre, ImplFactory.signer);
++                const TransparentUpgradeableProxyFactory = await (opts.proxyFactory || utils_1.getTransparentUpgradeableProxyFactory(hre, ImplFactory.signer))
++
+                 proxyDeployment = Object.assign({ kind }, await utils_1.deploy(TransparentUpgradeableProxyFactory, impl, adminAddress, data));
+                 break;
+             }
+diff --git a/node_modules/@openzeppelin/hardhat-upgrades/src/deploy-proxy.ts b/node_modules/@openzeppelin/hardhat-upgrades/src/deploy-proxy.ts
+index c8beb0d..b187875 100644
+--- a/node_modules/@openzeppelin/hardhat-upgrades/src/deploy-proxy.ts
++++ b/node_modules/@openzeppelin/hardhat-upgrades/src/deploy-proxy.ts
+@@ -25,6 +25,7 @@ export interface DeployFunction {
+ 
+ export interface DeployOptions extends ValidationOptions {
+   initializer?: string | false;
++  proxyFactory?: any;
+ }
+ 
+ export function makeDeployProxy(hre: HardhatRuntimeEnvironment): DeployFunction {
+@@ -59,7 +60,8 @@ export function makeDeployProxy(hre: HardhatRuntimeEnvironment): DeployFunction
+     let proxyDeployment: Required<ProxyDeployment>;
+     switch (kind) {
+       case 'uups': {
+-        const ProxyFactory = await getProxyFactory(hre, ImplFactory.signer);
++        const ProxyFactory = await (opts.proxyFactory || getProxyFactory(hre, ImplFactory.signer));
++
+         proxyDeployment = Object.assign({ kind }, await deploy(ProxyFactory, impl, data));
+         break;
+       }
+@@ -67,7 +69,8 @@ export function makeDeployProxy(hre: HardhatRuntimeEnvironment): DeployFunction
+       case 'transparent': {
+         const AdminFactory = await getProxyAdminFactory(hre, ImplFactory.signer);
+         const adminAddress = await fetchOrDeployAdmin(provider, () => deploy(AdminFactory));
+-        const TransparentUpgradeableProxyFactory = await getTransparentUpgradeableProxyFactory(hre, ImplFactory.signer);
++        const TransparentUpgradeableProxyFactory = await (opts.proxyFactory || getTransparentUpgradeableProxyFactory(hre, ImplFactory.signer););
++
+         proxyDeployment = Object.assign(
+           { kind },
+           await deploy(TransparentUpgradeableProxyFactory, impl, adminAddress, data),

package/patches/@openzeppelin+upgrades-core+1.4.2.patch

@@ -0,0 +1,21 @@
+diff --git a/node_modules/@openzeppelin/upgrades-core/dist/provider.js b/node_modules/@openzeppelin/upgrades-core/dist/provider.js
+index 1fd10da..d80cf45 100644
+--- a/node_modules/@openzeppelin/upgrades-core/dist/provider.js
++++ b/node_modules/@openzeppelin/upgrades-core/dist/provider.js
+@@ -33,14 +33,14 @@ async function getTransactionByHash(provider, txHash) {
+     return provider.send('eth_getTransactionByHash', [txHash]);
+ }
+ exports.getTransactionByHash = getTransactionByHash;
+-exports.networkNames = Object.freeze({
++exports.networkNames = {
+     1: 'mainnet',
+     2: 'morden',
+     3: 'ropsten',
+     4: 'rinkeby',
+     5: 'goerli',
+     42: 'kovan',
+-});
++};
+ async function isDevelopmentNetwork(provider) {
+     const chainId = await getChainId(provider);
+     //  1337 => ganache and geth --dev

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/upgradeToV2/upgradeToV2.ts

@@ -88,8 +88,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 +99,7 @@ export const main = async (
   };
   console.log(`networkName ${networkName}`, {
     isTest,
-    isBackendTest,
+    isDappTest,
     isCoverage,
     isMainnet,
     isDevelop
@@ -843,14 +843,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 +877,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/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);
+  });
+});