@gooddollar/goodprotocol 2.1.4 → 2.2.0-beta.1

package/scripts/upgradeToV2/upgradeToV2.ts

@@ -1,853 +0,0 @@
-/**
- * Mainnet:
- * 0. deploy nameService
- * 1. deploy votingmachine  +  reputation
- * 2. deploy Reserve, MarketMaker
- * 3. deploy FundManager
- * 4. deploy ubi staking contracts
- */
-
-import { network, ethers, upgrades, run } from "hardhat";
-import { isFunction, get, omitBy } from "lodash";
-import { getImplementationAddress } from "@openzeppelin/upgrades-core";
-import pressAnyKey from "press-any-key";
-import { AaveStakingFactory, CompoundStakingFactory, ProxyFactory1967 } from "../../types";
-import SchemeRegistrarABI from "@gooddollar/goodcontracts/build/contracts/SchemeRegistrar.json";
-import releaser from "../releaser";
-import {
-  GReputation,
-  SchemeRegistrar,
-  CompoundVotingMachine,
-  ProtocolUpgrade,
-  ProtocolUpgradeFuse,
-  NameService
-} from "../../types";
-import { getFounders } from "../getFounders";
-import OldDAO from "../../releases/olddao.json";
-
-import ProtocolSettings from "../../releases/deploy-settings.json";
-import { keccak256 } from "ethers/lib/utils";
-
-let GAS_SETTINGS: any = {
-  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({
-  network: network.name,
-  upgrade: process.env.UPGRADE
-});
-const { name } = network;
-
-export const main = async (networkName = name, isPerformUpgrade = true, olddao?): Promise<{ [key: string]: any }> => {
-  const isProduction = networkName.startsWith("production");
-  if (isProduction && networkName.includes("mainnet")) {
-    GAS_SETTINGS.gasLimit = 6000000;
-    GAS_SETTINGS.maxFeePerGas = ethers.utils.parseUnits("80", "gwei");
-  } else if (network.config.chainId === 122) {
-    //case we are on fusefuse
-    GAS_SETTINGS = {
-      gasLimit: 6000000,
-      gasPrice: ethers.utils.parseUnits("1", "gwei")
-    };
-  } else if (network.config.chainId === 3 || network.config.chainId === 42) {
-    GAS_SETTINGS = {
-      maxPriorityFeePerGas: ethers.utils.parseUnits("1", "gwei"),
-      maxFeePerGas: ethers.utils.parseUnits("10", "gwei"),
-      gasLimit: 6000000
-    };
-  }
-
-  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");
-  let protocolSettings = {
-    ...ProtocolSettings["default"],
-    ...ProtocolSettings[networkName]
-  };
-  console.log(`networkName ${networkName}`, {
-    isTest,
-    isDappTest,
-    isCoverage,
-    isMainnet,
-    isDevelop
-  });
-  const dao = olddao || OldDAO[networkName];
-  const fse = require("fs-extra");
-  const ProtocolAddresses = await fse.readJson("releases/deployment.json");
-  const newfusedao = await ProtocolAddresses[networkName.replace(/\-mainnet/, "")];
-  const newdao = ProtocolAddresses[networkName] || {};
-
-  let [root, proxyDeployer] = await ethers.getSigners();
-
-  let avatar = dao.Avatar;
-  let controller = dao.Controller;
-  let repStateId = isMainnet ? "fuse" : "rootState";
-
-  const founders = await getFounders(networkName);
-
-  console.log(`root: ${root.address} founders: ${founders.map(_ => _.address)}`);
-
-  const compoundTokens = [
-    {
-      name: "cdai",
-      address: (protocolSettings.compound != undefined && protocolSettings.compound.cdai) || dao.cDAI,
-      usdOracle: (protocolSettings.compound != undefined && protocolSettings.compound.daiUsdOracle) || dao.DAIUsdOracle,
-      compUsdOracle:
-        (protocolSettings.compound != undefined && protocolSettings.compound.compUsdOracle) || dao.COMPUsdOracle,
-      swapPath: []
-    }
-  ];
-
-  const aaveTokens = [
-    {
-      name: "usdc",
-      address: protocolSettings.aave.usdc || dao.USDC,
-      usdOracle: protocolSettings.aave.usdcUsdOracle || dao.USDCUsdOracle,
-      aaveUsdOracle: protocolSettings.aave.aaveUsdOracle || dao.AAVEUsdOracle,
-      swapPath: [get(protocolSettings, "aave.usdc", dao.USDC), get(protocolSettings, "compound.dai", dao.DAI)]
-    }
-  ];
-
-  let release: { [key: string]: any } = newdao;
-
-  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: [
-        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,
-        protocolSettings.governance.guardian || root.address,
-        () => get(release, "GReputation", newdao.GReputation)
-      ]
-    },
-    {
-      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) {
-      return (proxyFactory = (await ethers.getContractAt(
-        "ProxyFactory1967",
-        newdao.ProxyFactory
-      )) as unknown as ProxyFactory1967);
-    } else {
-      console.info("deploying ProxyFactory1967", isDevelop, newdao.ProxyFactory);
-      // await pressAnyKey();
-
-      const pf = await (await ethers.getContractFactory("ProxyFactory1967", root)).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) {
-          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,
-            kind: "uups",
-            unsafeAllowLinkedLibraries: true
-          });
-          await countTotalGas(tx, contract.name);
-          return tx;
-        }
-        console.log("Deploying:", contract.name, "using proxyfactory");
-        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) {
-          console.log("Deploying:", contract.name, "using proxyfactory code");
-          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 {
-          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();
-          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" && (contract.network === "mainnet") !== isMainnet) {
-        console.log(contract, " Skipping non mainnet/sidechain contract:", contract.network, contract.name);
-        continue;
-      }
-      if (isDevelop === false && newdao[contract.name]) {
-        console.log(
-          contract.name,
-          " Skipping deployed contract at:",
-          newdao[contract.name],
-          "upgrading:",
-          !!process.env.UPGRADE
-        );
-        continue;
-      }
-
-      const args = await Promise.all(contract.args.map(async _ => await (isFunction(_) ? _() : _)));
-
-      console.log(`deploying contract upgrade ${contract.name}`, {
-        args
-        // release
-        // pf: ProxyFactory.factory.address
-      });
-      // await pressAnyKey();
-      let opts = {};
-      if (contract.libraries) {
-        let libraries = {};
-        contract.libraries.forEach(l => (libraries[l] = release[l]));
-        opts = { libraries };
-      }
-      const Contract = await ethers.getContractFactory(contract.name, opts);
-
-      let deployed = await deployDeterministic(contract, args, opts);
-
-      console.log(`${contract.name} deployed to: ${deployed.address}`);
-      release[contract.name] = deployed.address;
-      await releaser(release, networkName, "deployment", false);
-    }
-
-    if (!isProduction || get(release, "StakingContracts", []).length == 0) {
-      const { DonationsStaking, StakingContracts } = isMainnet && (await deployStakingContracts(release));
-      release["StakingContracts"] = StakingContracts;
-      release["DonationsStaking"] = DonationsStaking;
-      console.log("staking contracts result:", {
-        StakingContracts,
-        DonationsStaking
-      });
-    }
-
-    release["network"] = networkName;
-    release["networkId"] = network.config.chainId || 4447;
-    if (!isMainnet) {
-      release["HomeBridge"] = dao.HomeBridge;
-      release["SignupBonus"] = dao.SignupBonus;
-      release["OneTimePayments"] = dao.OneTimePayments;
-      release["Invites"] = dao.Invites;
-      release["AdminWallet"] = dao.AdminWallet;
-    } else {
-      release["ForeignBridge"] = dao.ForeignBridge;
-      release["Contribution"] = dao.Contribution;
-    }
-
-    release["Identity"] = dao.Identity;
-    release["GoodDollar"] = dao.GoodDollar;
-    release["Controller"] = dao.Controller;
-    release["Avatar"] = avatar;
-    release["FirstClaimPool"] = dao.FirstClaimPool;
-    release["ProxyAdmin"] = dao.ProxyAdmin;
-    release["BancorFormula"] = protocolSettings.bancor || dao.BancorFormula;
-
-    release["DAI"] = get(protocolSettings, "compound.dai", dao.DAI);
-    release["cDAI"] = get(protocolSettings, "compound.cdai", dao.cDAI);
-    release["COMP"] = get(protocolSettings, "compound.comp", dao.COMP);
-
-    release = omitBy(release, _ => _ === undefined);
-    let res = Object.assign(newdao, release);
-    await releaser(release, networkName);
-    return release;
-  };
-
-  // const proveNewRep = async () => {
-  //   console.log("prooving new rep...");
-  //   if (networkName.includes("production") === false) {
-  //     const proofs = [
-  //       [
-  //         "0x23d8bd1cdfa398986bb91927d3011fb1ded1425b6ae3ff794e497235481fe57f",
-  //         "0xe4ac4e67088f036e8dc535fee10a3ad42065e444d2b0bd3668e0df21e1590db3",
-  //       ],
-  //       ["0x4c01c2c86a047dc65fc8ff0a1d9ac11842597af9a363711e4db7dcabcfda307b"],
-  //       [
-  //         "0x235dc3126b01e763befb96ead059e3f19d0380e65e477e6ebb95c1d9fc90e0b7",
-  //         "0xe4ac4e67088f036e8dc535fee10a3ad42065e444d2b0bd3668e0df21e1590db3",
-  //       ],
-  //     ];
-  //     let proofResults = await Promise.all(
-  //       founders.map((f, idx) =>
-  //         grep
-  //           .connect(f)
-  //           .proveBalanceOfAtBlockchain(repStateId, f.address, 100, proofs[idx])
-  //           .then((_) => _.wait())
-  //       )
-  //     );
-  //     console.log(
-  //       "proofs:",
-  //       proofResults.map((_) => _.events)
-  //     );
-  //   } else {
-  //     //prove foundation multi sig account
-  //     const proof = [];
-  //     const foundationAddress = protocolSettings.governance.foundationAddress;
-  //     let proofResult = await grep
-  //       .proveBalanceOfAtBlockchain(
-  //         repStateId,
-  //         foundationAddress,
-  //         12000000,
-  //         proof
-  //       )
-  //       .then((_) => _.wait());
-
-  //     console.log("proofs:", proofResult.events);
-  //   }
-  // };
-
-  const performUpgrade = async release => {
-    const isKovan = networkName.includes("kovan");
-    const upgrade: ProtocolUpgrade = (await ethers.getContractAt(
-      "ProtocolUpgrade",
-      release.ProtocolUpgrade
-    )) as unknown as ProtocolUpgrade;
-
-    console.log("performing protocol v2 upgrade on Mainnet...", {
-      release,
-      dao
-    });
-    console.log("upgrading nameservice + staking rewards...");
-    let tx;
-    tx = await (
-      await upgrade.upgradeBasic(
-        release.NameService,
-        [
-          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("RESERVE")),
-          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("MARKET_MAKER")),
-          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("FUND_MANAGER")),
-          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("REPUTATION")),
-          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("GDAO_STAKERS")),
-          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("BRIDGE_CONTRACT")),
-          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("UBI_RECIPIENT")),
-          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("EXCHANGE_HELPER"))
-        ],
-        [
-          release.GoodReserveCDai,
-          release.GoodMarketMaker,
-          release.GoodFundManager,
-          release.GReputation,
-          release.StakersDistribution,
-          dao.ForeignBridge,
-          isKovan ? root.address : newfusedao.UBIScheme, //fake for kovan
-          release.ExchangeHelper
-        ],
-        release.StakingContracts.map((_: any) => _[0]),
-        release.StakingContracts.map((_: any) => _[1])
-      )
-    ).wait();
-    await countTotalGas(tx, "call upgrade basic");
-
-    console.log("upgrading reserve...", {
-      params: [release.NameService, dao.Reserve, dao.MarketMaker, dao.FundManager, release.COMP]
-    });
-    tx = await upgrade.upgradeReserve(
-      release.NameService,
-      dao.Reserve,
-      dao.MarketMaker,
-      dao.FundManager,
-      release.COMP,
-      GAS_SETTINGS
-    );
-    await countTotalGas(tx, "call upgrade reserve");
-    console.log("upgrading donationstaking...", {
-      params: [
-        release.NameService,
-        dao.DonationsStaking, //old
-        release.DonationsStaking
-      ]
-    });
-    tx = await upgrade.upgradeDonationStaking(
-      release.NameService,
-      dao.DonationsStaking, //old
-      release.DonationsStaking, //new
-      dao.DAIStaking,
-      GAS_SETTINGS
-    );
-    await countTotalGas(tx, "call upgrade donations");
-    console.log("Donation staking upgraded");
-    //extract just the addresses without the rewards
-    // release.StakingContracts = release.StakingContracts.map((_) => _[0]);
-
-    if (isProduction) {
-      console.log("SKIPPING GOVERNANCE UPGRADE FOR PRODUCTION. RUN IT MANUALLY");
-    } else {
-      console.log("upgrading governance...");
-
-      tx = await upgrade.upgradeGovernance(dao.SchemeRegistrar, dao.UpgradeScheme, release.CompoundVotingMachine);
-      await countTotalGas(tx, "call upgrade gov");
-    }
-  };
-
-  const performUpgradeFuse = async release => {
-    const upgrade: ProtocolUpgradeFuse = (await ethers.getContractAt(
-      "ProtocolUpgradeFuse",
-      release.ProtocolUpgradeFuse
-    )) as unknown as ProtocolUpgradeFuse;
-
-    console.log("performing protocol v2 upgrade on Fuse...", { release, dao });
-    await upgrade
-      .upgrade(
-        release.NameService,
-        //old contracts
-        [dao.SchemeRegistrar || ethers.constants.AddressZero, dao.UpgradeScheme, dao.UBIScheme, dao.FirstClaimPool],
-        release.UBIScheme,
-        [
-          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("REPUTATION")),
-          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("BRIDGE_CONTRACT")),
-          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("UBISCHEME")),
-          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("GDAO_STAKING")),
-          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("GDAO_CLAIMERS"))
-        ],
-        [
-          release.GReputation,
-          dao.HomeBridge,
-          release.UBIScheme,
-          release.GovernanceStaking,
-          release.ClaimersDistribution
-        ],
-        GAS_SETTINGS
-      )
-      .then(_ => countTotalGas(_, "fuse basic upgrade"));
-
-    if (isProduction) {
-      console.log("SKIPPING GOVERNANCE UPGRADE FOR PRODUCTION. RUN IT MANUALLY");
-    } else {
-      console.log("upgrading governance...");
-
-      await upgrade.upgradeGovernance(
-        dao.SchemeRegistrar,
-        dao.UpgradeScheme,
-        release.CompoundVotingMachine,
-        GAS_SETTINGS
-      );
-    }
-  };
-
-  //give Avatar permissions to the upgrade process contract
-  const voteProtocolUpgrade = async release => {
-    const Upgrade = release.ProtocolUpgrade || release.ProtocolUpgradeFuse;
-
-    console.log("approve upgrade scheme in dao...", Upgrade, dao.SchemeRegistrar);
-
-    const schemeRegistrar: SchemeRegistrar = (await ethers.getContractAt(
-      "SchemeRegistrar",
-      dao.SchemeRegistrar
-    )) as unknown as SchemeRegistrar;
-    console.log("proprosing scheme ...");
-
-    const proposal = await (
-      await schemeRegistrar.proposeScheme(
-        avatar,
-        Upgrade,
-        ethers.constants.HashZero,
-        "0x0000001F",
-        ethers.utils.keccak256(ethers.utils.toUtf8Bytes("ProtocolUpgrade"))
-      )
-    ).wait();
-    await countTotalGas(proposal, "propose upgrade");
-
-    console.log("proposal tx:", proposal.transactionHash);
-    let proposalId = proposal.events.find(_ => _.event === "NewSchemeProposal").args._proposalId;
-
-    console.log("proposal", { scheme: Upgrade, proposalId });
-
-    console.log("voting...");
-
-    const absoluteVote = await ethers.getContractAt(
-      ["function vote(bytes32,uint,uint,address) returns (bool)"],
-      dao.AbsoluteVote
-    );
-
-    console.log("voteUpgradeScheme", {
-      absoluteVote: dao.AbsoluteVote,
-      founders
-    });
-    await Promise.all(
-      founders.slice(1).map(f =>
-        absoluteVote
-          .connect(f)
-          .vote(proposalId, 1, 0, f.address, {
-            ...GAS_SETTINGS,
-            gasLimit: 300000
-          })
-          .then(_ => countTotalGas(_.wait(), "vote"))
-          .catch(e => console.log("founder vote failed:", f.address, e.message))
-      )
-    );
-  };
-
-  const deployStakingContracts = async release => {
-    const isRopsten = networkName === "fuse-mainnet" || networkName === "staging-mainnet";
-    console.log("deployStakingContracts", {
-      factory: release.CompoundStakingFactory,
-      ns: release.NameService
-    });
-    const compfactory = await ethers.getContractAt("CompoundStakingFactory", release.CompoundStakingFactory);
-    const aavefactory = await ethers.getContractAt("AaveStakingFactory", release.AaveStakingFactory);
-    const compps = compoundTokens.map(async token => {
-      let rewardsPerBlock = protocolSettings.staking.rewardsPerBlock;
-      console.log("deployStakingContracts", {
-        token,
-        settings: protocolSettings.staking,
-        rewardsPerBlock,
-        factory: compfactory.address,
-        params: [
-          token.address,
-          release.NameService,
-          protocolSettings.staking.fullRewardsThreshold, //blocks before switching for 0.5x rewards to 1x multiplier
-          token.usdOracle,
-          token.compUsdOracle
-        ]
-      });
-      const tx = await (
-        await compfactory["cloneAndInit(address,address,uint64,address,address,address[])"](
-          token.address,
-          release.NameService,
-          protocolSettings.staking.fullRewardsThreshold, //blocks before switching for 0.5x rewards to 1x multiplier
-          token.usdOracle,
-          token.compUsdOracle,
-          token.swapPath,
-          GAS_SETTINGS
-        )
-      ).wait();
-      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}`);
-      return [log.args.proxy, rewardsPerBlock];
-    });
-
-    await Promise.all(compps);
-    // const compps = [
-    //   Promise.resolve(["0x9999c40c8b88c740076b15d2e708db6a7a071b53", 13888])
-    // ];
-    let deployed;
-    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 aave", {
-          token,
-          settings: protocolSettings.staking,
-          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["cloneAndInit(address,address,address,uint64,address,address,address,address[])"](
-            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
-          )
-        ).wait();
-        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}`);
-        return [log.args.proxy, rewardsPerBlock];
-      });
-
-      // const aaveps = [
-      //   Promise.resolve(["0x8f0c4f59b4c593193e5b5e0224d848ac803ad1a2", 13888 / 2])
-      // ];
-      await Promise.all(aaveps);
-      deployed = await Promise.all(compps.concat(aaveps));
-    } else {
-      deployed = await Promise.all(compps);
-    }
-
-    console.log("deploying donation staking");
-    console.log(`release ${release}`);
-    const deployedDonationsStaking = await deployDeterministic(
-      {
-        network: "mainnet",
-        name: "DonationsStaking",
-        isUpgradable: true
-      },
-      [
-        release.NameService,
-        deployed[0][0],
-        ["0x0000000000000000000000000000000000000000", get(protocolSettings, "compound.dai", dao.DAI)],
-        [get(protocolSettings, "compound.dai", dao.DAI), "0x0000000000000000000000000000000000000000"]
-      ],
-      { libraries: { UniswapV2SwapHelper: release["UniswapV2SwapHelper"] } }
-    );
-    // await countTotalGas(deployedDonationsStaking);
-
-    console.log(`DonationsStaking deployed to: ${deployedDonationsStaking.address}`);
-
-    return {
-      DonationsStaking: deployedDonationsStaking.address,
-      StakingContracts: deployed
-    };
-  };
-  const verifyContracts = async release => {
-    for (let contract of toDeployUpgradable) {
-      if (contract.network !== "both" && (contract.network === "mainnet") !== isMainnet) {
-        console.log(
-          contract,
-          " Skipping verification non mainnet/sidechain contract:",
-          contract.network,
-          contract.name
-        );
-        continue;
-      }
-      console.log("Running contract verification:", { contract }, release[contract.name]);
-      if (contract.isUpgradable !== false) {
-        const implementationAddress = await getImplementationAddress(network.provider, release[contract.name]);
-        try {
-          await run("verify:verify", {
-            address: implementationAddress
-          });
-        } catch (err) {
-          console.log("err", err);
-        }
-      } else {
-        try {
-          await run("verify:verify", {
-            address: release[contract.name],
-            constructorArguments: contract.args,
-            libraries: {
-              UniswapV2SwapHelper: release["UniswapV2SwapHelper"]
-            }
-          });
-        } catch (err) {
-          console.log("err", err);
-        }
-      }
-    }
-  };
-
-  await deployContracts();
-
-  if (isPerformUpgrade) {
-    console.log("deployed contracts", { totalGas, dao, release });
-    if (isTest === false) await pressAnyKey();
-    await voteProtocolUpgrade(release);
-    if (isTest === false) await pressAnyKey();
-    console.log("voted contracts", { totalGas });
-    isMainnet && (await performUpgrade(release));
-    !isMainnet && (await performUpgradeFuse(release));
-    console.log("upgraded contracts", { totalGas });
-  }
-  if (isMainnet && !isTest && !isCoverage) {
-    await verifyContracts(release);
-  }
-
-  await releaser(release, networkName);
-  return release;
-  // await proveNewRep();
-};
-if (network.name !== "hardhat" && process.argv[1].includes("upgradeToV2.ts")) {
-  main(name, false)
-    .catch(e => {
-      console.log(e);
-      throw e;
-    })
-    .finally(() => {
-      console.log({ totalGas, gasUsage });
-    });
-}