@gooddollar/goodprotocol 1.0.0-beta.32 → 1.0.0-beta.42

package/scripts/upgradeToV2/upgradeToV2.ts

@@ -10,7 +10,11 @@
 import { network, ethers, upgrades } from "hardhat";
 import { networkNames } from "@openzeppelin/upgrades-core";
 import { isFunction, get } from "lodash";
-import { AaveStakingFactory, CompoundStakingFactory } from "../../types";
+import {
+  AaveStakingFactory,
+  CompoundStakingFactory,
+  ProxyFactory1967
+} from "../../types";
 import SchemeRegistrarABI from "@gooddollar/goodcontracts/build/contracts/SchemeRegistrar.json";
 import releaser from "../releaser";
 import {
@@ -26,6 +30,26 @@ import { fetchOrDeployProxyFactory } from "../fetchOrDeployProxyFactory";
 import OldDAO from "../../releases/olddao.json";
 
 import ProtocolSettings from "../../releases/deploy-settings.json";
+import { keccak256 } from "@ethersproject/keccak256";
+
+const GAS_SETTINGS = {
+  maxPriorityFeePerGas: ethers.utils.parseUnits("1", "gwei"),
+  maxFeePerGas: ethers.utils.parseUnits("50", "gwei"),
+  gasLimit: 30000000
+};
+
+let totalGas = 0;
+const gasUsage = {};
+const countTotalGas = async (tx, name) => {
+  let res = tx;
+  if (tx.deployTransaction) tx = tx.deployTransaction;
+  if (tx.wait) res = await tx.wait();
+  if (res.gasUsed) {
+    totalGas += parseInt(res.gasUsed);
+    gasUsage[name] = gasUsage[name] || 0;
+    gasUsage[name] += parseInt(res.gasUsed);
+  } else console.log("no gas data", { res, tx });
+};
 
 console.log({
   networkNames,
@@ -34,7 +58,11 @@ console.log({
 });
 const { name } = network;
 
-export const main = async (networkName = name) => {
+export const main = async (
+  networkName = name,
+  isPerformUpgrade = true,
+  olddao?
+) => {
   if (networkName.startsWith("dapptest") === false) {
     networkNames[1] = networkName;
     networkNames[122] = networkName;
@@ -42,7 +70,12 @@ export const main = async (networkName = name) => {
   }
 
   const isProduction = networkName.startsWith("production");
+  if (isProduction) {
+    GAS_SETTINGS.gasLimit = 7000000;
+  }
   const isBackendTest = networkName.startsWith("dapptest");
+  const isTest = network.name === "hardhat";
+  const isCoverage = process.env.CODE_COVERAGE;
   const isDevelop = !isProduction;
   const isMainnet = networkName.includes("mainnet");
   let protocolSettings = {
@@ -50,7 +83,7 @@ export const main = async (networkName = name) => {
     ...ProtocolSettings[networkName]
   };
   console.log(`networkName ${networkName}`);
-  const dao = OldDAO[networkName];
+  const dao = olddao || OldDAO[networkName];
   const fse = require("fs-extra");
   const ProtocolAddresses = await fse.readJson("releases/deployment.json");
   const newfusedao = await ProtocolAddresses[
@@ -58,14 +91,12 @@ export const main = async (networkName = name) => {
   ];
   const newdao = ProtocolAddresses[networkName] || {};
 
-  let [root] = await ethers.getSigners();
+  let [root, proxyDeployer] = await ethers.getSigners();
 
   let avatar = dao.Avatar;
   let controller = dao.Controller;
   let repStateId = isMainnet ? "fuse" : "rootState";
-  let oldVotingMachine = dao.SchemeRegistrar;
 
-  let grep: GReputation, vm: CompoundVotingMachine;
   const founders = await getFounders(networkName);
 
   const compoundTokens = [
@@ -100,187 +131,286 @@ export const main = async (networkName = name) => {
     }
   ];
 
-  let totalGas = 0;
-  const countTotalGas = async tx => {
-    let res = tx;
-    if (tx.deployTransaction) tx = tx.deployTransaction;
-    if (tx.wait) res = await tx.wait();
-    if (res.gasUsed) totalGas += parseInt(res.gasUsed);
-    else console.log("no gas data", { res, tx });
-  };
+  let release = {};
 
-  const deployContracts = async () => {
-    console.log({ dao, newdao, protocolSettings });
-    let release = {};
-
-    const toDeployUpgradable = [
-      {
-        network: "mainnet",
-        name: "NameService",
-        args: [
-          controller,
-          [
-            "CONTROLLER",
-            "AVATAR",
-            "IDENTITY",
-            "GOODDOLLAR",
-            "CONTRIBUTION_CALCULATION",
-            "BANCOR_FORMULA",
-            "DAI",
-            "CDAI",
-            "COMP",
-            "BRIDGE_CONTRACT",
-            "UNISWAP_ROUTER",
-            "GAS_PRICE_ORACLE",
-            "DAI_ETH_ORACLE",
-            "ETH_USD_ORACLE"
-          ].map(_ => ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))),
-          [
-            controller,
-            avatar,
-            dao.Identity,
-            dao.GoodDollar,
-            dao.Contribution,
-            protocolSettings.bancor || dao.BancorFormula,
-            get(protocolSettings, "compound.dai", dao.DAI),
-            get(protocolSettings, "compound.cdai", dao.cDAI),
-            get(protocolSettings, "compound.comp", dao.COMP),
-            dao.ForeignBridge,
-            protocolSettings.uniswapRouter || dao.UniswapRouter,
-            !isMainnet ||
-              dao.GasPriceOracle ||
-              protocolSettings.chainlink.gasPrice, //should fail if missing only on mainnet
-            !isMainnet ||
-              dao.DAIEthOracle ||
-              protocolSettings.chainlink.dai_eth,
-            !isMainnet || dao.ETHUsdOracle || protocolSettings.chainlink.eth_usd
-          ]
-        ]
-      },
-      {
-        network: "fuse",
-        name: "NameService",
-        args: [
+  const toDeployUpgradable = [
+    {
+      network: "mainnet",
+      name: "NameService",
+      args: [
+        controller,
+        [
+          "CONTROLLER",
+          "AVATAR",
+          "IDENTITY",
+          "GOODDOLLAR",
+          "CONTRIBUTION_CALCULATION",
+          "BANCOR_FORMULA",
+          "DAI",
+          "CDAI",
+          "COMP",
+          "BRIDGE_CONTRACT",
+          "UNISWAP_ROUTER",
+          "GAS_PRICE_ORACLE",
+          "DAI_ETH_ORACLE",
+          "ETH_USD_ORACLE"
+        ].map(_ => ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))),
+        [
           controller,
-          [
-            "CONTROLLER",
-            "AVATAR",
-            "IDENTITY",
-            "GOODDOLLAR",
-            "BRIDGE_CONTRACT"
-          ].map(_ => ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))),
-          [controller, avatar, dao.Identity, dao.GoodDollar, dao.HomeBridge]
-        ]
-      },
-      {
-        network: "both",
-        name: "GReputation",
-        initializer: "initialize(address, string, bytes32, uint256)",
-        args: [
-          () => get(release, "NameService", newdao.NameService),
-          repStateId,
-          protocolSettings.governance.gdaoAirdrop, //should fail on real deploy if not set
-          protocolSettings.governance.gdaoTotalSupply //should fail on real deploy if not set
-        ]
-      },
-      {
-        network: "both",
-        name: "CompoundVotingMachine",
-        args: [
-          () => get(release, "NameService", newdao.NameService),
-          protocolSettings.governance.proposalVotingPeriod
-        ]
-      },
-      {
-        network: "mainnet",
-        name: "GoodMarketMaker",
-        args: [
-          () => get(release, "NameService", newdao.NameService),
-          protocolSettings.expansionRatio.nom,
-          protocolSettings.expansionRatio.denom
-        ]
-      },
-      {
-        network: "mainnet",
-        name: "GoodReserveCDai",
-        initializer: "initialize(address, bytes32)",
-        args: [
-          () => get(release, "NameService", newdao.NameService),
-          protocolSettings.gdxAirdrop
-        ]
-      },
-      {
-        network: "mainnet",
-        name: "ExchangeHelper",
-        initializer: "initialize(address)",
-        args: [() => get(release, "NameService", newdao.NameService)]
-      },
-      {
-        network: "mainnet",
-        name: "GoodFundManager",
-        args: [() => get(release, "NameService", newdao.NameService)]
-      },
-      {
-        network: "mainnet",
-        name: "StakersDistribution",
-        args: [() => get(release, "NameService", newdao.NameService)]
-      },
-      {
-        network: "fuse",
-        name: "ClaimersDistribution",
-        args: [() => get(release, "NameService", newdao.NameService)]
-      },
-      {
-        network: "fuse",
-        name: "GovernanceStaking",
-        args: [() => get(release, "NameService", newdao.NameService)],
-        isUpgradable: false
-      },
-      {
-        network: "fuse",
-        name: "UBIScheme",
-        initializer: "initialize(address, address, uint256)",
-        args: [
-          () => get(release, "NameService", newdao.NameService),
-          dao.FirstClaimPool,
-          14
+          avatar,
+          dao.Identity,
+          dao.GoodDollar,
+          dao.Contribution,
+          protocolSettings.bancor || dao.BancorFormula,
+          get(protocolSettings, "compound.dai", dao.DAI),
+          get(protocolSettings, "compound.cdai", dao.cDAI),
+          get(protocolSettings, "compound.comp", dao.COMP),
+          dao.ForeignBridge,
+          protocolSettings.uniswapRouter || dao.UniswapRouter,
+          !isMainnet ||
+            dao.GasPriceOracle ||
+            protocolSettings.chainlink.gasPrice, //should fail if missing only on mainnet
+          !isMainnet || dao.DAIEthOracle || protocolSettings.chainlink.dai_eth,
+          !isMainnet || dao.ETHUsdOracle || protocolSettings.chainlink.eth_usd
         ]
-      },
-      {
-        network: "mainnet",
-        name: "ProtocolUpgrade",
-        args: [dao.Controller],
-        isUpgradable: false,
-        initializer: null
-      },
-      {
-        network: "fuse",
-        name: "ProtocolUpgradeFuse",
-        args: [dao.Controller],
-        isUpgradable: false
-      },
-      {
-        network: "mainnet",
-        name: "UniswapV2SwapHelper",
-        args: [],
-        isUpgradable: false
-      },
-      {
-        network: "mainnet",
-        name: "CompoundStakingFactory",
-        args: [],
-        isUpgradable: false,
-        libraries: ["UniswapV2SwapHelper"]
-      },
-      {
-        network: "mainnet",
-        name: "AaveStakingFactory",
-        args: [],
-        isUpgradable: false,
-        libraries: ["UniswapV2SwapHelper"]
+      ]
+    },
+    {
+      network: "fuse",
+      name: "NameService",
+      args: [
+        controller,
+        [
+          "CONTROLLER",
+          "AVATAR",
+          "IDENTITY",
+          "GOODDOLLAR",
+          "BRIDGE_CONTRACT"
+        ].map(_ => ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))),
+        [controller, avatar, dao.Identity, dao.GoodDollar, dao.HomeBridge]
+      ]
+    },
+    {
+      network: "both",
+      name: "GReputation",
+      initializer: "initialize(address, string, bytes32, uint256)",
+      args: [
+        () => get(release, "NameService", newdao.NameService),
+        repStateId,
+        protocolSettings.governance.gdaoAirdrop, //should fail on real deploy if not set
+        protocolSettings.governance.gdaoTotalSupply //should fail on real deploy if not set
+      ]
+    },
+    {
+      network: "both",
+      name: "CompoundVotingMachine",
+      args: [
+        () => get(release, "NameService", newdao.NameService),
+        protocolSettings.governance.proposalVotingPeriod
+      ]
+    },
+    {
+      network: "mainnet",
+      name: "GoodMarketMaker",
+      args: [
+        () => get(release, "NameService", newdao.NameService),
+        protocolSettings.expansionRatio.nom,
+        protocolSettings.expansionRatio.denom
+      ]
+    },
+    {
+      network: "mainnet",
+      name: "GoodReserveCDai",
+      initializer: "initialize(address, bytes32)",
+      args: [
+        () => get(release, "NameService", newdao.NameService),
+        protocolSettings.gdxAirdrop
+      ]
+    },
+    {
+      network: "mainnet",
+      name: "ExchangeHelper",
+      initializer: "initialize(address)",
+      args: [() => get(release, "NameService", newdao.NameService)]
+    },
+    {
+      network: "mainnet",
+      name: "GoodFundManager",
+      args: [() => get(release, "NameService", newdao.NameService)]
+    },
+    {
+      network: "mainnet",
+      name: "StakersDistribution",
+      args: [() => get(release, "NameService", newdao.NameService)]
+    },
+    {
+      network: "fuse",
+      name: "ClaimersDistribution",
+      args: [() => get(release, "NameService", newdao.NameService)]
+    },
+    {
+      network: "fuse",
+      name: "GovernanceStaking",
+      args: [() => get(release, "NameService", newdao.NameService)],
+      isUpgradable: false
+    },
+    {
+      network: "fuse",
+      name: "UBIScheme",
+      initializer: "initialize(address, address, uint256)",
+      args: [
+        () => get(release, "NameService", newdao.NameService),
+        dao.FirstClaimPool,
+        14
+      ]
+    },
+    {
+      network: "mainnet",
+      name: "ProtocolUpgrade",
+      args: [dao.Controller, root.address],
+      isUpgradable: false,
+      initializer: null
+    },
+    {
+      network: "fuse",
+      name: "ProtocolUpgradeFuse",
+      args: [dao.Controller, root.address],
+      isUpgradable: false
+    },
+    {
+      network: "mainnet",
+      name: "UniswapV2SwapHelper",
+      args: [],
+      isUpgradable: false
+    },
+    {
+      network: "mainnet",
+      name: "CompoundStakingFactory",
+      args: [],
+      isUpgradable: false,
+      libraries: ["UniswapV2SwapHelper"]
+    },
+    {
+      network: "mainnet",
+      name: "AaveStakingFactory",
+      args: [],
+      isUpgradable: false,
+      libraries: ["UniswapV2SwapHelper"]
+    }
+  ];
+
+  let proxyFactory: ProxyFactory1967;
+  const getProxyFactory = async () => {
+    if (isDevelop === false && newdao.ProxyFactory) {
+      console.info("deploying ProxyFactory1967");
+      return (proxyFactory = ethers.getContractAt(
+        "ProxyFactory1967",
+        newdao.ProxyFactory
+      ) as unknown as ProxyFactory1967);
+    } else {
+      const pf = await (
+        await ethers.getContractFactory("ProxyFactory1967", proxyDeployer)
+      ).deploy(GAS_SETTINGS);
+      await pf.deployed();
+      await releaser(
+        { ProxyFactory: pf.address },
+        networkName,
+        "deployment",
+        false
+      );
+      return (proxyFactory = pf.connect(root) as unknown as ProxyFactory1967);
+    }
+  };
+
+  const deployDeterministic = async (
+    contract,
+    args: any[],
+    factoryOpts = {}
+  ) => {
+    try {
+      const Contract = await ethers.getContractFactory(
+        contract.name,
+        factoryOpts
+      );
+
+      const salt = ethers.BigNumber.from(
+        keccak256(ethers.utils.toUtf8Bytes(contract.name))
+      );
+
+      if (contract.isUpgradable !== false) {
+        if (isCoverage) {
+          //coverage has large contracts doesnt work with proxy factory
+          const tx = await upgrades.deployProxy(Contract, args, {
+            initializer: contract.initializer,
+            kind: "uups"
+          });
+          await countTotalGas(tx, contract.name);
+          return tx;
+        }
+        const encoded = Contract.interface.encodeFunctionData(
+          contract.initializer || "initialize",
+          args
+        );
+        const tx = await Contract.deploy(GAS_SETTINGS);
+        const impl = await tx.deployed();
+        await countTotalGas(tx, contract.name);
+
+        const tx2 = await proxyFactory.deployProxy(
+          salt,
+          impl.address,
+          encoded,
+          GAS_SETTINGS
+        );
+        await countTotalGas(tx2, contract.name);
+        const deployTx = await tx2
+          .wait()
+          .catch(e =>
+            console.error("failed to deploy proxy, assuming it exists...", e)
+          );
+        return ethers.getContractAt(
+          contract.name,
+          await proxyFactory["getDeploymentAddress(uint256,address)"](
+            salt,
+            root.address
+          )
+        );
+      } else {
+        //for some reason deploying with link library via proxy doesnt work on hardhat test env
+        if (isTest === false) {
+          const constructor = Contract.interface.encodeDeploy(args);
+          const bytecode = ethers.utils.solidityPack(
+            ["bytes", "bytes"],
+            [Contract.bytecode, constructor]
+          );
+          const deployTx = await (
+            await proxyFactory.deployCode(salt, bytecode, GAS_SETTINGS)
+          ).wait();
+          return ethers.getContractAt(
+            contract.name,
+            await proxyFactory["getDeploymentAddress(uint256,address,bytes32)"](
+              salt,
+              root.address,
+              keccak256(bytecode)
+            )
+          );
+        } else {
+          const tx = await Contract.deploy(...args, GAS_SETTINGS);
+          await countTotalGas(tx, contract.name);
+          const impl = await tx.deployed();
+          return impl;
+        }
       }
-    ];
+    } catch (e) {
+      console.log("Failed deploying contract:", { contract });
+      throw e;
+    }
+  };
+
+  const deployContracts = async () => {
+    console.log({ dao, newdao, protocolSettings });
 
+    await getProxyFactory();
+    console.info("got proxyfactory at:", proxyFactory.address);
     for (let contract of toDeployUpgradable) {
       if (
         contract.network !== "both" &&
@@ -310,8 +440,8 @@ export const main = async (networkName = name) => {
       );
 
       console.log(`deploying contract upgrade ${contract.name}`, {
-        args,
-        release
+        args
+        // release
         // pf: ProxyFactory.factory.address
       });
       let opts = {};
@@ -321,19 +451,11 @@ export const main = async (networkName = name) => {
         opts = { libraries };
       }
       const Contract = await ethers.getContractFactory(contract.name, opts);
-      //   const ProxyFactory = await fetchOrDeployProxyFactory();
-
-      let deployed;
-      if (contract.isUpgradable !== false)
-        deployed = await upgrades.deployProxy(Contract, args, {
-          // proxyFactory: ProxyFactory,
-          initializer: contract.initializer,
-          kind: "uups"
-        });
-      else deployed = await Contract.deploy(...args);
-      deployed.deployed();
-      countTotalGas(deployed);
+
+      let deployed = await deployDeterministic(contract, args, opts);
+
       console.log(`${contract.name} deployed to: ${deployed.address}`);
+      await releaser(release, networkName, "deployment", false);
       release[contract.name] = deployed.address;
     }
 
@@ -371,7 +493,7 @@ export const main = async (networkName = name) => {
     });
     let res = Object.assign(newdao, release);
     await releaser(release, networkName);
-    return res;
+    return release;
   };
 
   // const proveNewRep = async () => {
@@ -457,7 +579,7 @@ export const main = async (networkName = name) => {
         release.StakingContracts.map((_: any) => _[1])
       )
     ).wait();
-    await countTotalGas(tx);
+    await countTotalGas(tx, "call upgrade basic");
 
     console.log("upgrading reserve...", {
       params: [
@@ -475,7 +597,7 @@ export const main = async (networkName = name) => {
       dao.FundManager,
       dao.COMP
     );
-    await countTotalGas(tx);
+    await countTotalGas(tx, "call upgrade reserve");
     console.log("upgrading donationstaking...", {
       params: [
         release.NameService,
@@ -489,7 +611,7 @@ export const main = async (networkName = name) => {
       release.DonationsStaking, //new
       dao.DAIStaking
     );
-    await countTotalGas(tx);
+    await countTotalGas(tx, "call upgrade donations");
     console.log("Donation staking upgraded");
     //extract just the addresses without the rewards
     // release.StakingContracts = release.StakingContracts.map((_) => _[0]);
@@ -506,7 +628,7 @@ export const main = async (networkName = name) => {
         dao.UpgradeScheme,
         release.CompoundVotingMachine
       );
-      await countTotalGas(tx);
+      await countTotalGas(tx, "call upgrade gov");
     }
   };
 
@@ -585,7 +707,7 @@ export const main = async (networkName = name) => {
         ethers.utils.keccak256(ethers.utils.toUtf8Bytes("ProtocolUpgrade"))
       )
     ).wait();
-    await countTotalGas(proposal);
+    await countTotalGas(proposal, "propose upgrade");
 
     console.log("proposal tx:", proposal.transactionHash);
     let proposalId = proposal.events.find(_ => _.event === "NewSchemeProposal")
@@ -609,7 +731,7 @@ export const main = async (networkName = name) => {
         absoluteVote
           .connect(f)
           .vote(proposalId, 1, 0, f.address, { gasLimit: 300000 })
-          .then(_ => countTotalGas(_.wait()))
+          .then(_ => countTotalGas(_.wait(), "vote"))
           .catch(e => console.log("founder vote failed:", f.address, e.message))
       )
     );
@@ -655,7 +777,7 @@ export const main = async (networkName = name) => {
           token.swapPath
         )
       ).wait();
-      countTotalGas(tx);
+      await countTotalGas(tx, "deploy comp staking");
       const log = tx.events.find(_ => _.event === "Deployed");
       if (!log.args.proxy)
         throw new Error(`staking contract deploy failed ${token}`);
@@ -693,7 +815,7 @@ export const main = async (networkName = name) => {
             token.swapPath
           )
         ).wait();
-        await countTotalGas(tx);
+        await countTotalGas(tx, "deploy aave staking");
         const log = tx.events.find(_ => _.event === "Deployed");
         if (!log.args.proxy)
           throw new Error(`staking contract deploy failed ${token}`);
@@ -710,14 +832,15 @@ export const main = async (networkName = name) => {
     }
 
     console.log("deploying donation staking");
-    const deployedDonationsStaking = await upgrades.deployProxy(
-      await ethers.getContractFactory("DonationsStaking"),
-      [release.NameService, deployed[0][0]],
+    const deployedDonationsStaking = await deployDeterministic(
       {
-        kind: "uups"
-      }
+        network: "mainnet",
+        name: "DonationsStaking",
+        isUpgradable: true
+      },
+      [release.NameService, deployed[0][0]]
     );
-    await countTotalGas(deployedDonationsStaking);
+    // await countTotalGas(deployedDonationsStaking);
 
     console.log(
       `DonationsStaking deployed to: ${deployedDonationsStaking.address}`
@@ -727,26 +850,28 @@ export const main = async (networkName = name) => {
       DonationsStaking: deployedDonationsStaking.address,
       StakingContracts: deployed
     };
-
-    // return {
-    //   DonationsStaking: release["DonationsStaking"],
-    //   StakingContracts: deployed
-    // };
   };
 
-  const release: any = await deployContracts();
-  console.log("deployed contracts", { totalGas });
-  await voteProtocolUpgrade(release);
-  console.log("voted contracts", { totalGas });
-  isMainnet && (await performUpgrade(release));
-  !isMainnet && (await performUpgradeFuse(release));
-  console.log("upgraded contracts", { totalGas });
+  await deployContracts();
+  if (isPerformUpgrade) {
+    console.log("deployed contracts", { totalGas });
+    await voteProtocolUpgrade(release);
+    console.log("voted contracts", { totalGas });
+    isMainnet && (await performUpgrade(release));
+    !isMainnet && (await performUpgradeFuse(release));
+    console.log("upgraded contracts", { totalGas });
+  }
   await releaser(release, networkName);
+  return release;
   // await proveNewRep();
 };
-if (process.env.TEST != "true") {
-  main(name).catch(e => {
-    console.log(e);
-    throw e;
-  });
+if (network.name !== "hardhat") {
+  main(name)
+    .catch(e => {
+      console.log(e);
+      throw e;
+    })
+    .finally(() => {
+      console.log({ totalGas, gasUsage });
+    });
 }