@gooddollar/goodprotocol 2.0.25-beta.1 → 2.0.25-beta.10

package/scripts/multichain-deploy/helpers.ts

@@ -193,6 +193,10 @@ export const executeViaGuardian = async (
   const results = [];
   for (let i = 0; i < contracts.length; i++) {
     const contract = contracts[i];
+    if (!contract) {
+      console.warn("skipping executing missing contract", i, contracts[i], functionSigs[i], functionInputs[i])
+      continue;
+    }
     console.log("executing:", contracts[i], functionSigs[i], functionInputs[i]);
     const sigHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(functionSigs[i])).slice(0, 10);
     const encoded = ethers.utils.solidityPack(["bytes4", "bytes"], [sigHash, functionInputs[i]]);
@@ -404,9 +408,8 @@ export const verifyContract = async (
   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) : ""
-  } --network ${networkProvider}`;
+  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 }) => {
     console.log("Result for:", cmd);

package/scripts/proposals/identityAuthPeriod.ts

@@ -0,0 +1,229 @@
+/***
+ * 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";
+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());
+
+
+    console.log("got signers:", {
+        networkName,
+        root: root.address,
+        guardian: guardian.address,
+        balance: rootBalance,
+        guardianBalance: guardianBalance
+    });
+
+    const reducerContract = await ethers.deployContract("LastauthReduction", [release.NameService])
+    console.log("executing proposals");
+
+    const proposalContracts = [
+        release.Controller,
+    ];
+
+    const proposalEthValues = proposalContracts.map(_ => 0);
+
+    const proposalFunctionSignatures = [
+        "registerScheme(address,bytes32,bytes4,address)", //make sure mpb is a registered scheme so it can mint G$ tokens
+    ];
+
+    const proposalFunctionInputs = [
+        ethers.utils.defaultAbiCoder.encode(["address", "bytes32", "bytes4", "address"], [reducerContract.address, ethers.constants.HashZero, "0x0000001f", release.Avatar]),
+    ];
+
+    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) {
+        try {
+            while (true) {
+                await reducerContract.reduce()
+                let id = await ethers.getContractAt("IdentityV2", release.Identity);
+                console.log("authperiod", await id.authenticationPeriod());
+            }
+        } catch (error) {
+            console.log("reduce reverted:", error)
+        }
+
+    }
+};
+
+export const upgradeFuse = async () => {
+    const isProduction = networkName.includes("production");
+
+    let [root] = await ethers.getSigners();
+
+    //simulate produciton on fork
+    if (network.name === "hardhat" || network.name === "fork" || network.name === "localhost") {
+        networkName = "production";
+    }
+
+    let networkEnv = networkName.split("-")[0];
+
+
+    if (networkEnv === "fuse") networkEnv = "development";
+
+    let release: { [key: string]: any } = dao[networkEnv];
+
+    let guardian = root;
+    console.log({ networkEnv })
+    //simulate on fork, make sure safe has enough eth to simulate txs
+    if (network.name === "hardhat" || network.name === "localhost" || network.name === "fork") {
+        guardian = await ethers.getImpersonatedSigner(release.GuardiansSafe);
+
+        await root.sendTransaction({
+            value: ethers.constants.WeiPerEther.mul(3),
+            to: guardian.address
+        });
+    }
+
+
+    console.log({
+        networkEnv,
+        guardian: guardian.address,
+        isProduction,
+        avatarBalance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
+    });
+
+    const reducerContract = await ethers.deployContract("LastauthReduction", [release.NameService])
+
+    const proposalContracts = [
+        release.Controller,
+    ];
+
+    const proposalEthValues = proposalContracts.map(_ => 0);
+
+    const proposalFunctionSignatures = [
+        "registerScheme(address,bytes32,bytes4,address)", //make sure mpb is a registered scheme so it can mint G$ tokens
+    ];
+
+    const proposalFunctionInputs = [
+        ethers.utils.defaultAbiCoder.encode(["address", "bytes32", "bytes4", "address"], [reducerContract.address, ethers.constants.HashZero, "0x0000001f", release.Avatar]),
+    ];
+
+    if (isProduction) {
+        await executeViaSafe(
+            proposalContracts,
+            proposalEthValues,
+            proposalFunctionSignatures,
+            proposalFunctionInputs,
+            release.GuardiansSafe,
+            "fuse"
+        );
+    } 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) {
+        try {
+            while (true) {
+                await reducerContract.reduce()
+                let id = await ethers.getContractAt("IdentityV2", release.Identity);
+                let idOld = await ethers.getContractAt("IdentityV2", release.IdentityOld);
+
+                console.log("authperiod", await id.authenticationPeriod(), await idOld.authenticationPeriod());
+            }
+        } catch (error) {
+            console.log("reduce reverted:", error)
+        }
+    }
+
+
+};
+
+
+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;
+    }
+};
+
+main().catch(console.log);

package/scripts/proposals/reserveRestore.ts

@@ -0,0 +1,429 @@
+/***
+ * Mainnet:
+ * FIXES:
+ *  - prevent hacked funds burnFrom
+ *  - set GOOD rewards to 0
+ *  - prevent untrusted contracts in goodfundmanager
+ *  - use bonding curve for actual cDAI balance (prevent the "buy" instead of "transferTo" used in hack to trick reserve into minting UBI from interest)
+ *  - set exit contribution to 10%
+ *  - disable gdx
+ *  - fix reserve calculations of expansion/currentprice
+ *  - add requirement of guardians to approve on-chain proposals
+ *  - reserve should not trust exchange helper
+ *  - resere should not trust fundmanager for its starting balance
+ * 
+ * PLAN:
+ *  - pause staking
+ *  - prevent fusebridge usage
+ *  - set GOOD rewards to 0
+ *  - blacklist hacked accounts to prevent burn (transfer already blocked done via tax)
+ *  - withdraw funds from fuse
+ *  - transfer to MPB bridge
+ *  - upgrade reserve
+ *    - set new reserve ratio, supply(minus hacked funds) and reserve
+ *    - set contribution to 10%
+ *    - unpause reserve
+ *  - upgrade exchangeHelper
+ *  - upgrade goodfundmanager
+ *  - upgrade governance
+ *  - unpause reserve
+ *  - unpause goodfundmanager
+ *  - switch fuse distribution to use lz bridge insted of deprecated fuse bridge
+ * 
+ *
+ * Fuse:
+ * PLAN:
+ *  - prevent old fuse bridge usage
+ *  - upgrade governance
+ *
+ **/
+
+import { network, ethers } from "hardhat";
+import { reset, time } from "@nomicfoundation/hardhat-network-helpers";
+import { defaultsDeep, last } from "lodash";
+import prompt from "prompt";
+// import mpbDeployments from "@gooddollar/bridge-contracts/release/mpb.json"
+
+import { executeViaGuardian, executeViaSafe, verifyProductionSigner } from "../multichain-deploy/helpers";
+
+import ProtocolSettings from "../../releases/deploy-settings.json";
+
+import dao from "../../releases/deployment.json";
+import { ExchangeHelper, FuseOldBridgeKill, GoodFundManager, GoodMarketMaker, GoodReserveCDai, IGoodDollar, ReserveRestore } from "../../types";
+let { name: networkName } = network;
+
+
+const isSimulation = network.name === "hardhat" || network.name === "fork" || network.name === "localhost";
+
+// hacker and hacked multichain bridge accounts
+const LOCKED_ACCOUNTS = ["0xeC577447D314cf1e443e9f4488216651450DBE7c", "0xD17652350Cfd2A37bA2f947C910987a3B1A1c60d", "0x6738fA889fF31F82d9Fe8862ec025dbE318f3Fde"]
+const INITIAL_DAI = ethers.utils.parseEther("100000") // 100k
+// reserve funder (goodlabs safe)
+const funder = "0xF0652a820dd39EC956659E0018Da022132f2f40a"
+
+export const upgradeMainnet = async network => {
+  const isProduction = networkName.includes("production");
+  let [root, ...signers] = await ethers.getSigners();
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let guardian = root;
+
+  //simulate produciton on fork
+  if (isSimulation) {
+    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 (isSimulation) {
+    await reset("https://eth.drpc.org");
+    guardian = await ethers.getImpersonatedSigner(protocolSettings.guardiansSafe);
+
+    await root.sendTransaction({
+      value: ethers.utils.parseEther("1"),
+      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 reserveImpl = await ethers.deployContract("GoodReserveCDai");
+  const goodFundManagerImpl = await ethers.deployContract("GoodFundManager");
+  const exchangeHelperImpl = await ethers.deployContract("ExchangeHelper");
+  const stakersDistImpl = await ethers.deployContract("StakersDistribution");
+  const govImpl = await ethers.deployContract("CompoundVotingMachine");
+  const distHelperImplt = await ethers.deployContract("DistributionHelper");
+  const marketMakerImpl = await ethers.deployContract("GoodMarketMaker");
+  const upgradeImpl = await ethers.deployContract("ReserveRestore", [release.NameService]) as ReserveRestore;
+
+  const gd = (await ethers.getContractAt("IGoodDollar", release.GoodDollar)) as IGoodDollar;
+
+
+  // test blacklisting to prevent burn by hacker
+  if (isSimulation) {
+
+    const locked = await ethers.getImpersonatedSigner(LOCKED_ACCOUNTS[0]);
+    const tx = await gd
+      .connect(locked)
+      .burn("10")
+      .then(_ => _.wait())
+      .then(_ => _.status)
+      .catch(e => e);
+
+    console.log("Burn tx before:", tx);
+
+    const funderSigner = await ethers.getImpersonatedSigner(funder)
+    const dai = await ethers.getContractAt("IGoodDollar", release.DAI)
+    await dai.connect(funderSigner).approve(upgradeImpl.address, ethers.utils.parseEther("200000"))
+    const whale = await ethers.getImpersonatedSigner("0xa359Fc83C48277EedF375a5b6DC9Ec7D093aD3f2")
+    await dai.connect(whale).transfer(root.address, ethers.utils.parseEther("100000"))
+
+    const lockedFunds = await Promise.all(LOCKED_ACCOUNTS.map(_ => gd.balanceOf(_)))
+    const totalLocked = lockedFunds.reduce((acc, cur) => acc.add(cur), ethers.constants.Zero)
+    console.log({ totalLocked })
+
+  }
+
+  const startSupply = await gd.totalSupply();
+
+
+  console.log("executing proposals");
+
+  const proposalContracts = [
+    release.StakingContractsV3[0][0], // pause staking
+    release.StakingContractsV3[1][0], // pause staking
+    release.StakersDistribution, //set GOOD rewards to 0
+    release.GoodReserveCDai, //expansion ratio
+    release.ForeignBridge, // prevent from using
+    release.Identity, // set locked G$ accounts as blacklisted so cant do burn from
+    release.Identity, // set locked G$ accounts as blacklisted so cant do burn from
+    release.Identity, // set locked G$ accounts as blacklisted so cant do burnfrom
+    release.ForeignBridge, // claim bridge tokens to mpb bridge
+    release.GoodReserveCDai, //upgrade reserve
+    release.GoodFundManager,  //upgrade fundmanager
+    release.ExchangeHelper, //upgrade exchangehelper
+    release.DistributionHelper, //upgrade disthelper
+    release.StakersDistribution, //upgrade stakers dist
+    release.GoodMarketMaker, //upgrade mm
+    release.CompoundVotingMachine, // upgrade gov
+    release.DistributionHelper, // switch to lz bridge for fuse
+    release.ExchangeHelper, // activate upgrade changes
+    release.Controller,
+    // upgradeImpl.address,
+    release.GuardiansSafe + "_" + release.GoodReserveCDai
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "pause(bool)",
+    "pause(bool)",
+    "setMonthlyReputationDistribution(uint256)",
+    "setReserveRatioDailyExpansion(uint256,uint256)",
+    "setExecutionDailyLimit(uint256)", // set limit to 0 so old bridge cant be used
+    "addBlacklisted(address)",
+    "addBlacklisted(address)",
+    "addBlacklisted(address)",
+    "claimTokens(address,address)",
+    "upgradeTo(address)",
+    "upgradeTo(address)",
+    "upgradeTo(address)",
+    "upgradeTo(address)",
+    "upgradeTo(address)",
+    "upgradeTo(address)",
+    "upgradeTo(address)",
+    "addOrUpdateRecipient((uint32,uint32,address,uint8))",
+    "setAddresses()",
+    "registerScheme(address,bytes32,bytes4,address)", // give upgrade contract permissions
+    // "upgrade(address, uint256)",
+    "unpause()"
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(["bool"], [true]),
+    ethers.utils.defaultAbiCoder.encode(["bool"], [true]),
+    ethers.utils.defaultAbiCoder.encode(["uint256"], [0]),
+    ethers.utils.defaultAbiCoder.encode(["uint256", "uint256"], [999711382710978, 1e15]),
+    ethers.utils.defaultAbiCoder.encode(["uint256"], [0]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [LOCKED_ACCOUNTS[0]]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [LOCKED_ACCOUNTS[1]]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [LOCKED_ACCOUNTS[2]]),
+    ethers.utils.defaultAbiCoder.encode(["address", "address"], [release.GoodDollar, release.MpbBridge]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [reserveImpl.address]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [goodFundManagerImpl.address]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [exchangeHelperImpl.address]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [distHelperImplt.address]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [stakersDistImpl.address]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [marketMakerImpl.address]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [govImpl.address]),
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "uint32", "address", "uint8"],
+      [1000, 122, dao["production"].UBIScheme, 1] //10% chainId 122 ubischeme 1-lz bridge
+    ),
+    "0x", //setAddresses
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "bytes32", "bytes4", "address"],
+      [
+        upgradeImpl.address, //scheme
+        ethers.constants.HashZero, //paramshash
+        "0x000000f1", //permissions - minimal
+        release.Avatar
+      ]
+    ),
+    "0x"
+  ];
+
+  if (isProduction) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      protocolSettings.guardiansSafe,
+      "mainnet"
+    );
+  } else {
+    //simulation or dev envs
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkName
+    );
+  }
+
+  if (isSimulation) {
+    await mainnetPostChecks(upgradeImpl)
+  }
+};
+
+const mainnetPostChecks = async (upgradeImpl: ReserveRestore) => {
+  networkName = "production-mainnet";
+  let release: { [key: string]: any } = dao[networkName];
+
+  let [root, ...signers] = await ethers.getSigners();
+  const gd = await ethers.getContractAt("IGoodDollar", release.GoodDollar);
+
+  //execute the reserve initialization
+  (await upgradeImpl.upgrade(funder, INITIAL_DAI)).wait()
+
+
+  const locked = await ethers.getImpersonatedSigner(LOCKED_ACCOUNTS[0]);
+  const tx = await gd
+    .connect(locked)
+    .burn("10", { maxFeePerGas: 30e9, maxPriorityFeePerGas: 1e9, gasLimit: 200000 })
+    .then(_ => _.wait())
+    .then(_ => _.status)
+    .catch(e => e);
+  console.log("Burn tx after should fail:", tx);
+
+  const dai = await ethers.getContractAt("IGoodDollar", release.DAI);
+  const cdai = await ethers.getContractAt("IGoodDollar", release.cDAI);
+  const reserve = await ethers.getContractAt("GoodReserveCDai", release.GoodReserveCDai) as GoodReserveCDai
+  const mm = await ethers.getContractAt("GoodMarketMaker", release.GoodMarketMaker) as GoodMarketMaker
+  const newExpansion = await mm.reserveRatioDailyExpansion()
+  console.log("new expansion set:", newExpansion, newExpansion.mul(1e15).div(ethers.utils.parseEther("1000000000")).toNumber() / 1e15 === 0.999711382710978)
+  console.log("discount should be disabled:", await reserve.discountDisabled(), " gdx should be disabled:", await reserve.gdxDisabled());
+  const resereState = await mm.reserveTokens(release.cDAI)
+  console.log({ resereState })
+  const finalSupply = await gd.totalSupply();
+  const distHelper = await ethers.getContractAt("DistributionHelper", release.DistributionHelper)
+  const result = await distHelper.calcGDToSell(1e9)
+  console.log("how much G$ to sell to cover distribution fees out of 1M:", result.toNumber() / 100)
+  const [cdaiPriceBefore, daiPriceBefore] = await (await Promise.all([reserve.currentPrice(), reserve.currentPriceDAI()])).map(_ => _.toNumber())
+  console.log({ cdaiPriceBefore, daiPriceBefore })
+  const dex = await ethers.getContractAt("ExchangeHelper", release.ExchangeHelper) as ExchangeHelper
+  await dai.approve(dex.address, ethers.utils.parseEther("10000"))
+  await dex.buy([release.DAI], ethers.utils.parseEther("10000"), 0, 0, root.address);
+  // check g$ prices
+  const [cdaiPriceAfter, daiPriceAfter] = await (await Promise.all([reserve.currentPrice(), reserve.currentPriceDAI()])).map(_ => _.toNumber())
+  console.log("prices after buying form reserve with 10k DAI", { cdaiPriceAfter, daiPriceAfter })
+  await gd.approve(dex.address, await gd.balanceOf(root.address))
+  await dex.sell([release.DAI], await gd.balanceOf(root.address), 0, 0, root.address);
+  const daiBalanceAfterSell = await dai.balanceOf(root.address)
+  // expect a 10% sell fee
+  console.log("expect 10% sell fee (selling 10K gets only 9K of dai, balance should be ~99K):", { daiBalanceAfterSell })
+  const cdaiReserveBalance = await cdai.balanceOf(reserve.address)
+  console.log({ cdaiReserveBalance })
+
+  const [mpbBalance, fuseBalance] = await Promise.all([gd.balanceOf(release.MpbBridge), gd.balanceOf(release.ForeignBridge)])
+  console.log("fuse bridge should have 0 balance and Mpb should be >6B", { mpbBalance, fuseBalance })
+  const gfm = await ethers.getContractAt("GoodFundManager", release.GoodFundManager) as GoodFundManager
+  const stakingContracts = await gfm.callStatic.calcSortedContracts()
+  console.log({ stakingContracts })
+  const interesTX = await (await gfm.collectInterest(stakingContracts.map(_ => _[0]), false)).wait()
+  const ubiEvents = last(await reserve.queryFilter(reserve.filters.UBIMinted(), -1))
+  console.log("collectinterest gfm events:", interesTX.events?.find(_ => _.event === 'FundsTransferred'))
+  console.log("ubiEvents after collect interest:", ubiEvents)
+  // check expansion after some time
+  await time.increase(365 * 60 * 60 * 24)
+  const gdSupplyBeforeExpansion = await gd.totalSupply();
+  const reserveStateBeforeYearExpansion = await mm.reserveTokens(release.cDAI)
+
+  const expansionTX = await (await gfm.collectInterest([], false)).wait()
+  const ubiExpansionEvents = last(await reserve.queryFilter(reserve.filters.UBIMinted(), -1))
+  console.log("gfm events after 1 year expansion:", expansionTX.events?.filter(_ => _.event === 'FundsTransferred'))
+  console.log("ubiEvents after 1 year expansion:", ubiExpansionEvents)
+  const reserveStateAfterYearExpansion = await mm.reserveTokens(release.cDAI)
+  const gdSupplyAfterExpansion = await gd.totalSupply();
+  console.log({ reserveStateAfterYearExpansion, gdSupplyAfterExpansion, gdSupplyBeforeExpansion, reserveStateBeforeYearExpansion })
+
+  //execute the reserve initialization
+  await (await upgradeImpl.donate(funder, INITIAL_DAI)).wait()
+  const [cdaiPriceAfterDonation, daiPriceAfterDonation] = await (await Promise.all([reserve.currentPrice(), reserve.currentPriceDAI()])).map(_ => _.toNumber())
+  console.log("price after dai donation:", { cdaiPriceAfterDonation, daiPriceAfterDonation })
+  const reserveStateAfterDonation = await mm.reserveTokens(release.cDAI)
+  console.log({ reserveStateAfterDonation })
+
+  await (await upgradeImpl.end()).wait()
+}
+export const upgradeFuse = async network => {
+  let [root] = await ethers.getSigners();
+
+  const isProduction = networkName.includes("production");
+
+  let networkEnv = networkName.split("-")[0];
+  if (isSimulation) networkEnv = "production";
+
+  let release: { [key: string]: any } = dao[networkEnv];
+
+  let guardian = root;
+  //simulate on fork, make sure safe has enough eth to simulate txs
+  if (isSimulation) {
+    await reset("https://fuse.liquify.com");
+    guardian = await ethers.getImpersonatedSigner(release.GuardiansSafe);
+
+    await root.sendTransaction({ value: ethers.constants.WeiPerEther.mul(3), to: guardian.address });
+  }
+
+
+
+  const gd = (await ethers.getContractAt("IGoodDollar", release.GoodDollar)) as IGoodDollar;
+
+  const isMinter = await gd.isMinter(release.HomeBridge);
+
+  console.log({ networkEnv, guardian: guardian.address, isSimulation, isProduction, isMinter });
+
+  const govImpl = await ethers.deployContract("CompoundVotingMachine");
+  const killBridge = await ethers.deployContract("FuseOldBridgeKill") as FuseOldBridgeKill
+
+  const proposalContracts = [
+    release.HomeBridge, // prevent from using by upgrading to empty contract and removing minting rights
+    release.CompoundVotingMachine, //upgrade gov
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "upgradeToAndCall(uint256,address,bytes)", // upgrade and call end
+    "upgradeTo(address)"
+  ];
+
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(["uint256", "address", "bytes"], [2, killBridge.address, killBridge.interface.encodeFunctionData("end")]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [govImpl.address]),
+
+  ];
+
+  if (isProduction) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      release.GuardiansSafe,
+      "fuse"
+    );
+  } else {
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkEnv
+    );
+  }
+
+  if (isSimulation) {
+
+    const isMinter = await gd.isMinter(release.HomeBridge);
+    console.log("Fuse bridge scheme registration check:", isMinter ? "Failed" : "Success");
+  }
+};
+
+export const main = async () => {
+  prompt.start();
+  const { network } = await prompt.get(["network"]);
+
+  console.log("running step:", { network });
+  const chain = last(network.split("-"));
+  switch (chain) {
+    case "mainnet":
+      // await mainnetPostChecks()
+      await upgradeMainnet(network);
+
+      break;
+    case "fuse":
+      await upgradeFuse(network);
+
+      break;
+  }
+};
+
+main().catch(console.log);