@gooddollar/goodprotocol 2.0.23 → 2.0.25-beta.0

package/scripts/multichain-deploy/helpers.ts

@@ -12,18 +12,14 @@ import dao from "../../releases/deployment.json";
 
 const exec = util.promisify(require("child_process").exec);
 
-const networkName =
-  network.name === "localhost" ? "production-mainnet" : network.name;
+const networkName = network.name === "localhost" ? "production-mainnet" : network.name;
 let totalGas = 0;
 const gasUsage = {};
 const GAS_SETTINGS = { gasLimit: 10000000 };
 let release: { [key: string]: any } = dao[networkName];
 
 export const verifyProductionSigner = signer => {
-  if (
-    signer.address.toLowerCase() !==
-    "0x5128E3C1f8846724cc1007Af9b4189713922E4BB".toLowerCase()
-  ) {
+  if (signer.address.toLowerCase() !== "0x5128E3C1f8846724cc1007Af9b4189713922E4BB".toLowerCase()) {
     throw new Error(
       "signer not 0x5128E3C1f8846724cc1007Af9b4189713922E4BB to get same deployed addresses on production"
     );
@@ -77,9 +73,7 @@ export const deploySuperGoodDollar = async (
     []
   ).then(printDeploy)) as Contract;
 
-  await GoodDollarProxy.initializeProxy(SuperGoodDollar.address).then(
-    printDeploy
-  );
+  await GoodDollarProxy.initializeProxy(SuperGoodDollar.address).then(printDeploy);
 
   const OutFlowNFT = (await deployDeterministic(
     {
@@ -104,20 +98,11 @@ export const deploySuperGoodDollar = async (
     "initialize(string,string,uint256,address,address,address,address,address,address)"
   ](...tokenArgs, OutFlowNFT.address, InFlowNFT.address);
 
-  const GoodDollar = await ethers.getContractAt(
-    "ISuperGoodDollar",
-    GoodDollarProxy.address
-  );
+  const GoodDollar = await ethers.getContractAt("ISuperGoodDollar", GoodDollarProxy.address);
 
-  const constantInflowNFT = await ethers.getContractAt(
-    "ConstantInflowNFT",
-    InFlowNFT.address
-  );
+  const constantInflowNFT = await ethers.getContractAt("ConstantInflowNFT", InFlowNFT.address);
 
-  const constantOutflowNFT = await ethers.getContractAt(
-    "ConstantOutflowNFT",
-    OutFlowNFT.address
-  );
+  const constantOutflowNFT = await ethers.getContractAt("ConstantOutflowNFT", OutFlowNFT.address);
 
   await constantOutflowNFT
     .attach(OutFlowNFT.address)
@@ -137,31 +122,17 @@ export const deploySuperGoodDollar = async (
   return GoodDollar;
 };
 
-export const deployDeterministic = async (
-  contract,
-  args: any[],
-  factoryOpts = {},
-  redeployProxyFactory = false
-) => {
+export const deployDeterministic = async (contract, args: any[], factoryOpts = {}, redeployProxyFactory = false) => {
   try {
     let proxyFactory;
     if (networkName.startsWith("develop") && redeployProxyFactory) {
-      proxyFactory = await (
-        await ethers.getContractFactory("ProxyFactory1967")
-      ).deploy();
-    } else
-      proxyFactory = await ethers.getContractAt(
-        "ProxyFactory1967",
-        release.ProxyFactory
-      );
+      proxyFactory = await (await ethers.getContractFactory("ProxyFactory1967")).deploy();
+    } else proxyFactory = await ethers.getContractAt("ProxyFactory1967", release.ProxyFactory);
     const Contract =
-      (contract.factory as ContractFactory) ||
-      (await ethers.getContractFactory(contract.name, factoryOpts));
+      (contract.factory as ContractFactory) || (await ethers.getContractFactory(contract.name, factoryOpts));
 
     const salt = ethers.BigNumber.from(
-      ethers.utils.keccak256(
-        ethers.utils.toUtf8Bytes(contract.salt || contract.name)
-      )
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes(contract.salt || contract.name))
     );
 
     if (contract.isUpgradeable === true) {
@@ -169,30 +140,19 @@ export const deployDeterministic = async (
         args,
         proxyFactory: proxyFactory.address
       });
-      const encoded = Contract.interface.encodeFunctionData(
-        contract.initializer || "initialize",
-        args
-      );
+      const encoded = Contract.interface.encodeFunctionData(contract.initializer || "initialize", args);
       const tx = await Contract.deploy(GAS_SETTINGS);
       const impl = await tx.deployed();
       console.log("implementation deployed:", contract.name, impl.address);
       await countTotalGas(tx, contract.name);
 
-      const tx2 = await proxyFactory.deployProxy(
+      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));
+      const proxyAddr = await proxyFactory["getDeploymentAddress(uint256,address)"](
         salt,
-        impl.address,
-        encoded,
-        GAS_SETTINGS
+        await proxyFactory.signer.getAddress()
       );
-      await countTotalGas(tx2, contract.name);
-      const deployTx = await tx2
-        .wait()
-        .catch(e =>
-          console.error("failed to deploy proxy, assuming it exists...", e)
-        );
-      const proxyAddr = await proxyFactory[
-        "getDeploymentAddress(uint256,address)"
-      ](salt, await proxyFactory.signer.getAddress());
       console.log("proxy deployed:", contract.name, proxyAddr);
       return Contract.attach(proxyAddr);
     } else {
@@ -201,17 +161,10 @@ export const deployDeterministic = async (
         args
       });
       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();
+      const bytecode = ethers.utils.solidityPack(["bytes", "bytes"], [Contract.bytecode, constructor]);
+      const deployTx = await (await proxyFactory.deployCode(salt, bytecode, GAS_SETTINGS)).wait();
 
-      const proxyAddr = await proxyFactory[
-        "getDeploymentAddress(uint256,address,bytes32)"
-      ](
+      const proxyAddr = await proxyFactory["getDeploymentAddress(uint256,address,bytes32)"](
         salt,
         await proxyFactory.signer.getAddress(),
         ethers.utils.keccak256(bytecode)
@@ -235,9 +188,7 @@ export const executeViaGuardian = async (
   network?: string
 ) => {
   let release: { [key: string]: any } = dao[network || networkName];
-  const ctrl = await (
-    await ethers.getContractAt("Controller", release.Controller)
-  ).connect(guardian);
+  const ctrl = await (await ethers.getContractAt("Controller", release.Controller)).connect(guardian);
 
   const results = [];
   for (let i = 0; i < contracts.length; i++) {
@@ -258,23 +209,21 @@ export const executeViaGuardian = async (
 
       results.push(tx);
     } else {
-      const simulationResult = await ctrl.callStatic.genericCall(
-        contract,
-        encoded,
-        release.Avatar,
-        ethValues[i],
-        {
-          from: await guardian.getAddress(),
-          value: ethValues[i]
-        }
-      );
+      const simulationResult = await ctrl.callStatic.genericCall(contract, encoded, release.Avatar, ethValues[i], {
+        from: await guardian.getAddress()
+      });
       console.log("executing genericCall:", {
         sigHash,
+        contract,
         encoded,
         simulationResult
       });
       if (simulationResult[0] === false) throw new Error("simulation failed:" + contract);
-      const tx = await ctrl.genericCall(contract, encoded, release.Avatar, ethValues[i]).then(printDeploy);
+      const tx = await ctrl
+        .genericCall(contract, encoded, release.Avatar, ethValues[i], {
+          gasLimit: 8000000
+        })
+        .then(printDeploy);
       // console.log("generic call events:", tx.events);
       results.push(tx);
     }
@@ -291,32 +240,24 @@ export const executeViaSafe = async (
   safeSignerOrNetwork?: Signer | string,
   isSimulation = false
 ) => {
-  if (
-    typeof safeSignerOrNetwork !== "object" &&
-    !process.env.SAFEOWNER_PRIVATE_KEY
-  ) {
+  if (typeof safeSignerOrNetwork !== "object" && !process.env.SAFEOWNER_PRIVATE_KEY) {
     throw new Error("safe signer is missing");
   }
 
-  let safeSigner = new ethers.Wallet(
-    process.env.SAFEOWNER_PRIVATE_KEY,
-    new ethers.providers.CloudflareProvider()
-  );
+  let safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY, new ethers.providers.CloudflareProvider());
   if (typeof safeSignerOrNetwork === "string") {
     switch (safeSignerOrNetwork) {
       case "mainnet":
         break;
       case "celo":
-        safeSigner = new ethers.Wallet(
-          process.env.SAFEOWNER_PRIVATE_KEY
-        ).connect(
+        safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY).connect(
           new ethers.providers.JsonRpcProvider("https://forno.celo.org")
         );
         break;
       case "fuse":
-        safeSigner = new ethers.Wallet(
-          process.env.SAFEOWNER_PRIVATE_KEY
-        ).connect(new ethers.providers.JsonRpcProvider("https://rpc.fuse.io"));
+        safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY).connect(
+          new ethers.providers.JsonRpcProvider("https://rpc.fuse.io")
+        );
         break;
     }
   } else if (safeSignerOrNetwork) {
@@ -351,11 +292,7 @@ export const executeViaSafe = async (
   const safeSdk = await Safe.create({ ethAdapter, safeAddress });
 
   let release: { [key: string]: any } = dao[networkName];
-  const ctrl = await ethers.getContractAt(
-    "Controller",
-    release.Controller,
-    null
-  );
+  const ctrl = await ethers.getContractAt("Controller", release.Controller, null);
 
   const safeTransactionData: MetaTransactionData[] = [];
 
@@ -418,8 +355,7 @@ export const executeViaSafe = async (
         sigHash,
         simulationResult
       });
-      if (isSimulation === true && simulationResult[0] === false)
-        throw new Error("simulation failed:" + contract);
+      if (isSimulation === true && simulationResult[0] === false) throw new Error("simulation failed:" + contract);
       const genericEncode = ctrl.interface.encodeFunctionData("genericCall", [
         contract,
         encoded,
@@ -465,19 +401,12 @@ export const verifyContract = async (
   proxyName?: string,
   forcedConstructorArguments?: string
 ) => {
-  let networkProvider = networkName.includes("-")
-    ? networkName.split("-")[1]
-    : "fuse";
-  networkProvider =
-    networkProvider === "mainnet" ? "ethereum" : networkProvider;
+  let networkProvider = networkName.includes("-") ? networkName.split("-")[1] : "fuse";
+  networkProvider = networkProvider === "mainnet" ? "ethereum" : networkProvider;
   console.log("truffle compile...");
   await exec("npx truffle compile");
-  const cmd = `npx truffle run verify ${
-    proxyName ? "--custom-proxy " + proxyName : ""
-  } ${contractName}@${address} ${
-    forcedConstructorArguments
-      ? "--forceConstructorArgs string:" + forcedConstructorArguments.slice(2)
-      : ""
+  const cmd = `npx truffle run verify ${proxyName ? "--custom-proxy " + proxyName : ""} ${contractName}@${address} ${
+    forcedConstructorArguments ? "--forceConstructorArgs string:" + forcedConstructorArguments.slice(2) : ""
   } --network ${networkProvider}`;
   console.log("running...:", cmd);
   await exec(cmd).then(({ stdout, stderr }) => {

package/scripts/proposals/hack-ubi-recovery.ts

@@ -0,0 +1,414 @@
+/***
+ * Bring UBI distribution to a temporary working state
+ * Celo:
+ *  - upgrade bridge to be able to prevent UBI bridge transfers as result of the hack
+ *  - mark unexecuted bridge transfers as executed
+ *  - set UBI with new cycle params
+ *  - unpause ubi contract
+ * Fuse:
+ *  - withdraw ubi to avatar and bridge ubi to contract on celo
+ *  - burn excess UBI tokens
+ *  - set UBI with new cycle params
+ *  - unpause ubi contract
+ * Mainnet:
+ *  - withdraw excess UBI from bridge to avatar
+ *  - burn excess UBI from bridge
+ *
+ */
+
+import { network, ethers } from "hardhat";
+import { defaultsDeep, last } from "lodash";
+import prompt from "prompt";
+
+import { executeViaGuardian, executeViaSafe, verifyProductionSigner } from "../multichain-deploy/helpers";
+
+import ProtocolSettings from "../../releases/deploy-settings.json";
+
+import dao from "../../releases/deployment.json";
+import { BigNumber } from "ethers";
+let { name: networkName } = network;
+
+export const upgradeCelo = async () => {
+  const isProduction = networkName.includes("production");
+  let [root, ...signers] = await ethers.getSigners();
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let guardian = root;
+
+  //simulate produciton on fork
+  if (network.name === "hardhat" || network.name === "fork" || network.name === "localhost") {
+    networkName = "production-celo";
+  }
+
+  let release: { [key: string]: any } = dao[networkName];
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[networkName], ProtocolSettings["default"]);
+
+  //simulate on fork, make sure safe has enough eth to simulate txs
+  if (network.name === "hardhat" || network.name === "fork" || network.name === "localhost") {
+    guardian = await ethers.getImpersonatedSigner(protocolSettings.guardiansSafe);
+
+    await root.sendTransaction({
+      value: ethers.constants.WeiPerEther.mul(3),
+      to: protocolSettings.guardiansSafe
+    });
+  }
+
+  const rootBalance = await ethers.provider.getBalance(root.address).then(_ => _.toString());
+  const guardianBalance = await ethers.provider.getBalance(guardian.address).then(_ => _.toString());
+
+  const NEWBRIDGE_IMPL = "0x691dE730D97d545c141D13ED5e9c12b7cB384a73";
+
+  const ubiImpl = await ethers.deployContract("UBISchemeV2");
+
+  console.log("got signers:", {
+    networkName,
+    root: root.address,
+    guardian: guardian.address,
+    balance: rootBalance,
+    guardianBalance: guardianBalance
+  });
+
+  console.log("executing proposals");
+
+  const proposalContracts = [
+    release.MpbBridge, //controller -> upgrade bridge contract
+    release.MpbBridge, //mark request 0x3d959d3438182af92242207591931a28de09296035c08e355167c1f9aae0f7ab as executed
+    release.MpbBridge, //mark request 0x73dff6aa07a76330c9dbcb0920d9cbb67489e22d9dd452aaf867f4008f4e7598 as executed
+    release.MpbBridge, //mark request 0x8bf2c3df2954005b4ce077b68fce35f80b0e94efee349db5a417cdc8e2c52ba2 as executed
+    release.MpbBridge, //mark request 0x06d2ae5f6b7943c6d36da248512dfad48ace22c9447c3cacb9b403907678e5a2 as executed
+    release.UBIScheme, //set new ubi contract
+    release.UBIScheme, //set cycle length to 60 days
+    release.UBIScheme //unpause ubi
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "upgradeTo(address)", // set new bridge name
+    "preventRequest(uint256)", //prevent bridge hack ubi request
+    "preventRequest(uint256)", //prevent bridge hack ubi request
+    "preventRequest(uint256)", //prevent bridge hack ubi request
+    "preventRequest(uint256)", //prevent bridge hack ubi request
+    "upgradeTo(address)", // set new ubi contract
+    "setCycleLength(uint256)", //set new cycle length
+    "pause(bool)" // unpause ubi
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(["address"], [NEWBRIDGE_IMPL]),
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint256"],
+      ["0x3d959d3438182af92242207591931a28de09296035c08e355167c1f9aae0f7ab"]
+    ),
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint256"],
+      ["0x73dff6aa07a76330c9dbcb0920d9cbb67489e22d9dd452aaf867f4008f4e7598"]
+    ),
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint256"],
+      ["0x8bf2c3df2954005b4ce077b68fce35f80b0e94efee349db5a417cdc8e2c52ba2"]
+    ),
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint256"],
+      ["0x06d2ae5f6b7943c6d36da248512dfad48ace22c9447c3cacb9b403907678e5a2"]
+    ),
+    ethers.utils.defaultAbiCoder.encode(["address"], [ubiImpl.address]),
+    ethers.utils.defaultAbiCoder.encode(["uint256"], [60]),
+    ethers.utils.defaultAbiCoder.encode(["bool"], [false])
+  ];
+
+  if (isProduction) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      protocolSettings.guardiansSafe,
+      "celo"
+    );
+  } else {
+    //simulation or dev envs
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkName
+    );
+  }
+
+  //perform sanity checks on fork, for production we need to wait until everything executed
+  if (!isProduction) {
+    let ubi = await ethers.getContractAt("UBISchemeV2", release.UBIScheme);
+    let bridge = await ethers.getContractAt(
+      ["function executedRequests(uint256) view returns (bool)"],
+      release.MpbBridge
+    );
+
+    console.log(await bridge.executedRequests("0x3d959d3438182af92242207591931a28de09296035c08e355167c1f9aae0f7ab"));
+    console.log(await bridge.executedRequests("0x73dff6aa07a76330c9dbcb0920d9cbb67489e22d9dd452aaf867f4008f4e7598"));
+    console.log(await bridge.executedRequests("0x8bf2c3df2954005b4ce077b68fce35f80b0e94efee349db5a417cdc8e2c52ba2"));
+    console.log(await bridge.executedRequests("0x06d2ae5f6b7943c6d36da248512dfad48ace22c9447c3cacb9b403907678e5a2"));
+
+    console.log("cycle length", await ubi.cycleLength(), "ubi pause:", await ubi.paused());
+  }
+};
+
+export const upgradeFuse = async () => {
+  let [root] = await ethers.getSigners();
+
+  const isProduction = networkName.includes("production");
+
+  const isForkSimulation = networkName === "localhost";
+
+  let networkEnv = networkName.split("-")[0];
+  if (isForkSimulation) networkEnv = "production";
+
+  if (networkEnv === "fuse") networkEnv = "development";
+
+  let release: { [key: string]: any } = dao[networkEnv];
+
+  let guardian = root;
+  //simulate on fork, make sure safe has enough eth to simulate txs
+  if (network.name === "localhost" || network.name === "fork") {
+    guardian = await ethers.getImpersonatedSigner(release.GuardiansSafe);
+
+    await root.sendTransaction({
+      value: ethers.constants.WeiPerEther.mul(3),
+      to: guardian.address
+    });
+  }
+
+  const NEWBRIDGE = release["MpbBridge"];
+  const gd = await ethers.getContractAt("IERC20", release["GoodDollar"]);
+  const ubiGdBalance = await gd.balanceOf(release.UBIScheme);
+  const CELO_UBI_BALANCE = 1444008974;
+  const KEEP_UBI = 11e2 * 60 * 70000; // to keep on fuse 11 G$ for 60 days for 70k users
+  const EXCESS_UBI = ubiGdBalance.sub(BigNumber.from(KEEP_UBI));
+  const BRIDGE_UBI = 40e2 * 60 * 70000 - CELO_UBI_BALANCE; // out of excess ubi to bridge to celo 40 G$ for 60 days for 70k users
+  const BURN_UBI = EXCESS_UBI.sub(BigNumber.from(BRIDGE_UBI)).toString(); // out of excess ubi to burn
+
+  console.log({ EXCESS_UBI, KEEP_UBI, BURN_UBI, BRIDGE_UBI });
+  const gdTotalSupply = await gd.totalSupply();
+
+  console.log({
+    networkEnv,
+    NEWBRIDGE,
+    guardian: guardian.address,
+    isForkSimulation,
+    isProduction,
+    avatarBalance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
+  });
+
+  const proposalContracts = [
+    release.UBIScheme, //withdraw ubi
+    release.GoodDollar, // burn
+    release.GoodDollar, // approve to bridge
+    release.MpbBridge, // execute bridge (needs value)
+    release.UBIScheme, //set cycle length to 60 days
+    release.UBIScheme //unpause ubi
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => ethers.constants.Zero);
+  proposalEthValues[3] = ethers.utils.parseEther("0.8");
+
+  const proposalFunctionSignatures = [
+    "withdraw(uint256,address)", // withdraw excess ubi
+    "burn(uint256)", // burn excess ubi
+    "approve(address,uint256)", // approve bridge of excess ubi
+    "bridgeTo(address,uint256,uint256,uint8)", // bridge request to celo ubi
+    "setCycleLength(uint256)", //set new cycle length
+    "pause(bool)" // unpause ubi
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(["uint256", "address"], [EXCESS_UBI, release.Avatar]), //setAddresses(bytes32[],address[])"
+    ethers.utils.defaultAbiCoder.encode(["uint256"], [BURN_UBI]),
+    ethers.utils.defaultAbiCoder.encode(["address", "uint256"], [release.MpbBridge, BRIDGE_UBI]),
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "uint256", "uint256", "uint8"],
+      [dao["production-celo"].UBIScheme, 42220, BRIDGE_UBI, 1]
+    ),
+    ethers.utils.defaultAbiCoder.encode(["uint256"], [60]),
+    ethers.utils.defaultAbiCoder.encode(["bool"], [false])
+  ];
+
+  // make sure avatar has enough Fuse for bridge tx
+  await root.sendTransaction({
+    value: ethers.utils.parseEther("0.8"),
+    to: release.Avatar
+  });
+
+  console.log(
+    "bridge before allowance:",
+    await gd.allowance(release.Avatar, release.MpbBridge),
+    "avatarBalance",
+    await ethers.provider.getBalance(root.address).then(_ => _.toString())
+  );
+
+  if (isProduction) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      release.GuardiansSafe,
+      "fuse"
+    );
+  } else {
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkEnv
+    );
+  }
+
+  if (!isProduction) {
+    let ubi = await ethers.getContractAt("UBISchemeV2", release.UBIScheme);
+    let bridge = await ethers.getContractAt(
+      [
+        "event BridgeRequest(address indexed from, address indexed to, uint256 targetChainId, uint256 normalizedAmount, uint256 timestamp, uint8 bridge, uint256 indexed id)"
+      ],
+      release.MpbBridge
+    );
+
+    const finalAvatarBalance = await gd.balanceOf(release.Avatar);
+
+    const finalgdTotalSupply = await gd.totalSupply();
+    const finalubiGdBalance = await gd.balanceOf(release.UBIScheme);
+    console.log("burned:", gdTotalSupply.sub(finalgdTotalSupply), "to burn:", EXCESS_UBI);
+    console.log("ubi balance change:", ubiGdBalance.sub(finalubiGdBalance));
+
+    console.log("cycle length", await ubi.cycleLength(), "ubi pause:", await ubi.paused());
+    console.log("avatar balance:", finalAvatarBalance);
+    console.log("bridge allowance:", await gd.allowance(release.Avatar, release.MpbBridge));
+    const f = bridge.filters.BridgeRequest();
+    const events = await bridge.queryFilter(f);
+    console.log(last(events));
+  }
+};
+
+export const upgradeMainnet = async () => {
+  const isProduction = networkName.includes("production");
+  let [root, ...signers] = await ethers.getSigners();
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let guardian = root;
+
+  //simulate produciton on fork
+  if (network.name === "hardhat" || network.name === "fork" || network.name === "localhost") {
+    networkName = "production-mainnet";
+  }
+
+  let release: { [key: string]: any } = dao[networkName];
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[networkName], ProtocolSettings["default"]);
+
+  //simulate on fork, make sure safe has enough eth to simulate txs
+  if (network.name === "hardhat" || network.name === "fork" || network.name === "localhost") {
+    guardian = await ethers.getImpersonatedSigner(protocolSettings.guardiansSafe);
+
+    await root.sendTransaction({
+      value: ethers.constants.WeiPerEther.mul(3),
+      to: protocolSettings.guardiansSafe
+    });
+  }
+
+  const rootBalance = await ethers.provider.getBalance(root.address).then(_ => _.toString());
+  const guardianBalance = await ethers.provider.getBalance(guardian.address).then(_ => _.toString());
+
+  console.log("got signers:", {
+    networkName,
+    root: root.address,
+    guardian: guardian.address,
+    balance: rootBalance,
+    guardianBalance: guardianBalance
+  });
+
+  const CELO_UBI_BURN = 20193470562 + 161547764498 + 146346390158 + 18293298769; //hacker minted ubi
+  const FUSE_UBI_BURN = 20336841183; //hacker minted ubi, not including ubi left for 60 days
+  const TOTAL_BURN = CELO_UBI_BURN + FUSE_UBI_BURN;
+
+  const gd = await ethers.getContractAt("IERC20", release["GoodDollar"]);
+  const [bridgeBalance, totalSupply] = await Promise.all([gd.balanceOf(release.MpbBridge), gd.totalSupply()]);
+  console.log("executing proposals");
+
+  const proposalContracts = [
+    release.MpbBridge, //controller -> withdraw extra ubi funds from bridge
+    release.GoodDollar //burn
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "withdraw(address,uint256)", // withdraw ubi
+    "burn(uint256)" //burn ubi
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "uint256"],
+      ["0x67C5870b4A41D4Ebef24d2456547A03F1f3e094B", TOTAL_BURN]
+    ),
+    ethers.utils.defaultAbiCoder.encode(["uint256"], [TOTAL_BURN])
+  ];
+
+  if (isProduction) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      protocolSettings.guardiansSafe,
+      "mainnet"
+    );
+  } else {
+    //simulation or dev envs
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkName
+    );
+  }
+
+  //perform sanity checks on fork, for production we need to wait until everything executed
+  if (!isProduction) {
+    const [bridgeBalanceAfter, totalSupplyAfter] = await Promise.all([
+      gd.balanceOf(release.MpbBridge),
+      gd.totalSupply()
+    ]);
+    console.log("bridge balance before:", bridgeBalance.toString());
+    console.log("bridge balance before:", bridgeBalanceAfter.toString());
+    console.log("total supply before:", totalSupply.toString());
+    console.log("total supply after:", totalSupplyAfter.toString());
+  }
+};
+
+export const main = async () => {
+  prompt.start();
+  const { network } = await prompt.get(["network"]);
+
+  console.log("running step:", { network });
+  switch (network) {
+    case "celo":
+      await upgradeCelo();
+      break;
+    case "fuse":
+      await upgradeFuse();
+      break;
+    case "mainnet":
+      await upgradeMainnet();
+
+      break;
+  }
+};
+
+main().catch(console.log);