@gooddollar/goodprotocol 2.1.4 → 2.2.0-beta.1

package/scripts/upgradeToV2/upgradeToV2Recover.ts

@@ -1,939 +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,
-  ProtocolUpgradeRecover,
-  ProtocolUpgradeFuseRecover,
-  NameService
-} from "../../types";
-import OldDAO from "../../releases/olddao.json";
-
-import ProtocolSettings from "../../releases/deploy-settings.json";
-import { keccak256 } from "@ethersproject/keccak256";
-
-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 isBackendTest = networkName.startsWith("dapptest");
-  const isTest = network.name === "hardhat" || isBackendTest;
-  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,
-    isBackendTest,
-    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 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",
-      skip: true,
-      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",
-      skip: true,
-      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",
-      skip: true,
-      initializer: "initialize(address, string, bytes32, uint256)",
-      args: [
-        () => get(release, "NameService", newdao.NameService),
-        "",
-        ethers.constants.HashZero, //should fail on real deploy if not set
-        0 //should fail on real deploy if not set
-      ]
-    },
-    {
-      network: "both",
-      name: "CompoundVotingMachine",
-      skip: true,
-      args: [
-        () => get(release, "NameService", newdao.NameService),
-        protocolSettings.governance.proposalVotingPeriod,
-        protocolSettings.governance.guardian || root.address,
-        () => get(release, "GReputation", newdao.GReputation)
-      ]
-    },
-    {
-      network: "mainnet",
-      name: "GoodMarketMaker",
-      skip: true,
-      args: [
-        () => get(release, "NameService", newdao.NameService),
-        protocolSettings.expansionRatio.nom,
-        protocolSettings.expansionRatio.denom
-      ]
-    },
-    {
-      network: "mainnet",
-      name: "GoodReserveCDai",
-      skip: true,
-      initializer: "initialize(address, bytes32)",
-      args: [
-        () => get(release, "NameService", newdao.NameService),
-        ethers.constants.HashZero
-      ]
-    },
-    {
-      network: "mainnet",
-      name: "ExchangeHelper",
-      skip: true,
-      initializer: "initialize(address)",
-      args: [() => get(release, "NameService", newdao.NameService)]
-    },
-    {
-      network: "mainnet",
-      skip: true,
-      name: "GoodFundManager",
-      args: [() => get(release, "NameService", newdao.NameService)]
-    },
-    {
-      network: "mainnet",
-      skip: true,
-      name: "StakersDistribution",
-      args: [() => get(release, "NameService", newdao.NameService)]
-    },
-    {
-      network: "fuse",
-      name: "ClaimersDistribution",
-      skip: true,
-      args: [() => get(release, "NameService", newdao.NameService)]
-    },
-    {
-      network: "fuse",
-      skip: true,
-      name: "GovernanceStaking",
-      args: [() => get(release, "NameService", newdao.NameService)],
-      isUpgradable: false
-    },
-    {
-      network: "fuse",
-      name: "UBIScheme",
-      skip: true,
-      initializer: "initialize(address, address, uint256)",
-      args: [
-        () => get(release, "NameService", newdao.NameService),
-        dao.FirstClaimPool,
-        14
-      ]
-    },
-    {
-      network: "mainnet",
-      skip: true,
-      name: "ProtocolUpgradeRecover",
-      args: [dao.Controller, root.address],
-      isUpgradable: false,
-      initializer: null
-    },
-    {
-      network: "fuse",
-      skip: true,
-      name: "ProtocolUpgradeFuseRecover",
-      args: [dao.Controller, root.address],
-      isUpgradable: false
-    },
-    {
-      network: "mainnet",
-      skip: true,
-      name: "UniswapV2SwapHelper",
-      args: [],
-      isUpgradable: false
-    },
-    {
-      network: "mainnet",
-      skip: true,
-      name: "CompoundStakingFactory",
-      args: [],
-      isUpgradable: false,
-      libraries: ["UniswapV2SwapHelper"]
-    },
-    {
-      network: "mainnet",
-      skip: true,
-      name: "AaveStakingFactory",
-      args: [],
-      isUpgradable: false,
-      libraries: ["UniswapV2SwapHelper"]
-    }
-  ];
-
-  let proxyFactory: ProxyFactory1967;
-  const getProxyFactory = async () => {
-    return (proxyFactory = (await ethers.getContractAt(
-      "ProxyFactory1967",
-      "0xDa85fceD9Bd193526b7667F2AD1fD4A0F900d3A7"
-    )) 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");
-          await pressAnyKey();
-          //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
-        );
-        await pressAnyKey();
-        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");
-          await pressAnyKey();
-          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");
-          await pressAnyKey();
-          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.skip ||
-        (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
-      });
-      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 gasSettings = {
-      ...GAS_SETTINGS,
-      maxFeePerGas: ethers.utils.parseUnits("70", "gwei"),
-      gasLimit: 600000
-    };
-
-    const isKovan = networkName.includes("kovan");
-    const upgrade: ProtocolUpgradeRecover = (await ethers.getContractAt(
-      "ProtocolUpgradeRecover",
-      release.ProtocolUpgradeRecover
-    )) as unknown as ProtocolUpgradeRecover;
-
-    console.log("performing protocol v2 recovery on Mainnet...", {
-      release,
-      dao
-    });
-    const basicArgs: [any, any, any] = [
-      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("UBI_RECIPIENT")),
-        ethers.utils.keccak256(ethers.utils.toUtf8Bytes("BRIDGE_CONTRACT")),
-        ethers.utils.keccak256(ethers.utils.toUtf8Bytes("EXCHANGE_HELPER"))
-      ],
-      [
-        release.GoodReserveCDai,
-        release.GoodMarketMaker,
-        //   release.GoodFundManager,
-        //   release.GReputation,
-        //   release.StakersDistribution,
-        //   isKovan ? root.address : newfusedao.UBIScheme, //fake for kovan
-        dao.ForeignBridge,
-        release.ExchangeHelper
-      ]
-    ];
-    console.log("upgrading nameservice + staking rewards...", { basicArgs });
-    let tx;
-    await pressAnyKey();
-
-    tx = await (await upgrade.upgradeBasic(...basicArgs, gasSettings)).wait();
-    await countTotalGas(tx, "call upgrade basic");
-
-    const reserveArgs: [any] = [release.NameService];
-    console.log("upgrading reserve...", {
-      reserveArgs
-    });
-    await pressAnyKey();
-    tx = await upgrade.upgradeReserve(...reserveArgs, gasSettings);
-    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(release.CompoundVotingMachine);
-      await countTotalGas(tx, "call upgrade gov");
-    }
-  };
-
-  const performUpgradeFuse = async release => {
-    const upgrade: ProtocolUpgradeFuseRecover = (await ethers.getContractAt(
-      "ProtocolUpgradeFuseRecover",
-      release.ProtocolUpgradeFuseRecover
-    )) as unknown as ProtocolUpgradeFuseRecover;
-
-    console.log("performing protocol v2 upgrade on Fuse...", { release, dao });
-    await upgrade
-      .upgrade(
-        release.NameService,
-        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.ProtocolUpgradeRecover || release.ProtocolUpgradeFuseRecover;
-    const ctrl = await ethers.getContractAt("Controller", controller);
-    const tx = await ctrl.registerScheme(
-      Upgrade,
-      ethers.constants.HashZero,
-      "0x0000001f",
-      avatar,
-      {
-        ...GAS_SETTINGS,
-        gasLimit: 300000
-      }
-    );
-    await countTotalGas(tx, "registerScheme voteProtocolUpgrade");
-    console.log("registerScheme recovery scheme in dao...", Upgrade);
-  };
-
-  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 (!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", {
-          token,
-          settings: protocolSettings.staking,
-          rewardsPerBlock
-        });
-        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: "0x62305662fA7c4BC442803b940d9192DbDC92D710"
-        }
-      }
-    );
-    // 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: "0x62305662fA7c4BC442803b940d9192DbDC92D710"
-            }
-          });
-        } catch (err) {
-          console.log("err", err);
-        }
-      }
-    }
-  };
-
-  await deployContracts();
-
-  if (isPerformUpgrade) {
-    console.log("deployed contracts", { totalGas, dao, release });
-    console.log("registering updrade scheme...");
-    await pressAnyKey();
-    await voteProtocolUpgrade(release);
-    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("upgradeToV2Recover.ts")
-) {
-  main(name, true)
-    .catch(e => {
-      console.log(e);
-      throw e;
-    })
-    .finally(() => {
-      console.log({ totalGas, gasUsage });
-    });
-}