@gooddollar/goodprotocol 2.0.25-beta.9 → 2.0.26-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "2.0.25-beta.9",
+  "version": "2.0.26-beta.0",
   "description": "GoodDollar Protocol",
   "engines": {
     "node": ">=16.x"
@@ -107,7 +107,7 @@
     "fs-extra": "9.0.0",
     "graphql": "^15.5.0",
     "graphql-request": "^3.4.0",
-    "hardhat": "^2.17.3",
+    "hardhat": "^2.*",
     "hardhat-contract-sizer": "^2.6.1",
     "hardhat-gas-reporter": "^1.0.8",
     "hardhat-storage-layout": "^0.1.7",
@@ -133,7 +133,7 @@
     "typechain": "^8.3.1",
     "typescript": "^5.3.3"
   },
-  "packageManager": "yarn@3.6.0",
+  "packageManager": "yarn@3.6.1",
   "resolutions": {
     "@swc/core": "1.3.96"
   },

package/releases/deployment.json

@@ -434,6 +434,7 @@
     "StaticOracle": "0x00851A91a3c4E9a4c1B48df827Bacc1f884bdE28",
     "BuyGDFactory": "0x00e533B7d6255D05b7f15034B1c989c21F51b91C",
     "BuyGDFactoryV2": "0x1F60C4C7037C6766924A43666B781ED1479587a2",
+    "CUSD": "0x765DE816845861e75A25fCA122bb6898B8B1282a",
     "BulkWhitelist": "0x30Afd0534dAA29135308d048103b40dc1BA4518d"
   },
   "gnosis": { "GuardiansSafe": "0x84c10b45fe51bfb4f86c19a47fdbc187d4572fb8" },
@@ -608,5 +609,10 @@
     "DAI": "0xfcDB4564c18A9134002b9771816092C9693622e3",
     "cDAI": "0x32EEce76C2C2e8758584A83Ee2F522D4788feA0f",
     "COMP": "0x927b167526bAbB9be047421db732C663a0b77B11"
+  },
+  "development-base": {
+    "ProxyFactory": "0x5B22F5623ECB00E288539346F389E05f65e226ae",
+    "AdminWallet": "0x6672C998C49635aA6825Be355fF2e731f417B674",
+    "SuperfluidFaucet": "0x0c86C82eb8d6a8E991bbc37C58e23344b20520a2"
   }
 }

package/scripts/multichain-deploy/0_proxyFactory-deploy.ts

@@ -23,6 +23,9 @@ export const deployUniversalProxyFactory = async () => {
     s: "0x2222222222222222222222222222222222222222222222222222222222222222"
   };
   //modify tx data a little so we get different contract address for different envs
+  if (name.includes("development-base")) {
+    deployTx.gasPrice = 7e7;
+  }
   if (name.includes("staging")) {
     deployTx.gasLimit = 892000;
   } else if (name.includes("production")) {
@@ -34,12 +37,18 @@ export const deployUniversalProxyFactory = async () => {
   const deployer = ethers.utils.recoverAddress(txHash, signer);
   let [funder] = await ethers.getSigners();
 
-  let tx = await (
-    await funder.sendTransaction({
-      to: deployer,
-      value: ethers.BigNumber.from(deployTx.gasPrice).mul(deployTx.gasLimit)
-    })
-  ).wait();
+  const curBalance = await ethers.provider.getBalance(deployer);
+  const deployCost = ethers.BigNumber.from(deployTx.gasPrice).mul(deployTx.gasLimit);
+
+  let tx = {};
+  if (curBalance.lt(deployCost)) {
+    tx = await (
+      await funder.sendTransaction({
+        to: deployer,
+        value: deployCost.sub(curBalance)
+      })
+    ).wait();
+  }
 
   if (isProduction) verifyProductionSigner(funder);
 
@@ -47,23 +56,19 @@ export const deployUniversalProxyFactory = async () => {
     fundingTx: tx.transactionHash,
     deployer,
     funder: funder.address,
-    deployerBalance: ethers.utils.formatUnits(
-      await ethers.provider.getBalance(deployer)
-    )
+    deployerBalance: ethers.utils.formatUnits(await ethers.provider.getBalance(deployer))
   });
   const signedTx = ethers.utils.serializeTransaction(deployTx, signer);
-  const result = await (await ethers.provider.sendTransaction(signedTx)).wait();
-  console.log({ result });
+  const proxyTx = await ethers.provider.sendTransaction(signedTx);
+  console.log({ proxyTx });
+  const result = await proxyTx.wait();
   return ethers.getContractAt("ProxyFactory1967", result.contractAddress);
 };
 
 export const deployProxy = async (defaultAdmin = null) => {
   let release: { [key: string]: any } = dao[network.name] || {};
 
-  if (
-    network.name.match(/production|staging|fuse|development/) &&
-    release.ProxyFactory
-  ) {
+  if (network.name.match(/production|staging|fuse|development/) && release.ProxyFactory) {
     throw new Error("ProxyFactory already exists for env");
   }
   // let [root] = await ethers.getSigners();

package/scripts/multichain-deploy/7_superfluidfaucet-deploy.ts

@@ -0,0 +1,95 @@
+/***
+ * Deploy helper contracts
+ * AdminWallet, Faucet, Invites
+ */
+import { network, ethers, upgrades, run } from "hardhat";
+import { Contract } from "ethers";
+import { defaultsDeep } from "lodash";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
+import { deployDeterministic, verifyProductionSigner, verifyContract } from "./helpers";
+import releaser from "../releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { TransactionResponse } from "@ethersproject/providers";
+
+const { name } = network;
+
+const printDeploy = async (c: Contract | TransactionResponse): Promise<Contract | TransactionResponse> => {
+  if (c instanceof Contract) {
+    await c.deployed();
+    console.log("deployed to: ", c.address);
+  }
+  if (c.wait) {
+    await c.wait();
+    console.log("tx done:", c.hash);
+  }
+  return c;
+};
+
+export const deployHelpers = async () => {
+  let release: { [key: string]: any } = dao[network.name] || {};
+
+  let [root] = await ethers.getSigners();
+  const isProduction = network.name.includes("production");
+
+  if (isProduction) verifyProductionSigner(root);
+
+  //generic call permissions
+  let schemeMock = root;
+
+  console.log("got signers:", {
+    network,
+    root: root.address,
+    schemeMock: schemeMock.address,
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
+  });
+
+  const walletAdmins = [];
+  for (let i = 0; i < 10; i++) {
+    const wallet = ethers.Wallet.fromMnemonic(process.env.ADMIN_WALLET_MNEMONIC, `m/44'/60'/0'/0/${i}`);
+    walletAdmins.push(wallet.address);
+  }
+
+  const gasprice = 1e8;
+  console.log("deploying adminwallet", { walletAdmins });
+  const AdminWallet = release.AdminWallet
+    ? await ethers.getContractAt("AdminWallet", release.AdminWallet)
+    : ((await deployDeterministic(
+        {
+          //   address payable[] memory _admins,
+          // NameService _ns,
+          // address _owner,
+          // uint256 _gasPrice
+          name: "AdminWallet",
+          salt: "AdminWallet",
+          isUpgradeable: true
+        },
+        [walletAdmins, ethers.constants.AddressZero, root.address, gasprice]
+      ).then(printDeploy)) as Contract);
+
+  const Faucet = release.SuperfluidFaucet
+    ? await ethers.getContractAt("SuperfluidFaucet", release.SuperfluidFaucet)
+    : ((await upgrades
+        .deployProxy(
+          await ethers.getContractFactory("SuperfluidFaucet"),
+          [ethers.utils.parseEther("0.000003"), ethers.utils.parseEther("0.000003"), 30, AdminWallet.address],
+          { kind: "uups" }
+        )
+        .then(printDeploy)) as Contract);
+
+  const torelease = {
+    SuperfluidFaucet: Faucet.address,
+    AdminWallet: AdminWallet.address
+  };
+  await releaser(torelease, network.name, "deployment", false);
+
+  let impl = await getImplementationAddress(ethers.provider, AdminWallet.address);
+  await verifyContract(impl, "contracts/utils/AdminWallet.sol:AdminWallet", network.name);
+  impl = await getImplementationAddress(ethers.provider, Faucet.address);
+  await verifyContract(impl, "contracts/fuseFaucet/SuperfluidFaucet.sol:SuperfluidFaucet", network.name);
+};
+
+export const main = async () => {
+  await deployHelpers();
+};
+if (process.argv[1].includes("7_superfluidfaucet")) main();

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]]);
@@ -395,18 +399,14 @@ export const executeViaSafe = async (
 
 export const verifyContract = async (
   address,
-  contractName,
+  contractPath,
   networkName = network.name,
   proxyName?: string,
   forcedConstructorArguments?: string
 ) => {
-  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) : ""
-  } --network ${networkProvider}`;
+  const cmd = `yarn hardhat verify --contract ${contractPath} ${address} ${
+    forcedConstructorArguments ?? ""
+  } --network ${networkName}`;
   console.log("running...:", cmd);
   await exec(cmd).then(({ stdout, stderr }) => {
     console.log("Result for:", cmd);

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);

package/scripts/test/localOldDaoDeploy.ts

@@ -650,7 +650,6 @@ export const deployUBI = async deployedDAO => {
   const lastBlock = await ethers.provider.getBlock("latest");
   const periodStart = await ubiScheme.periodStart().then(_ => _.toNumber());
   const diff = periodStart - lastBlock.timestamp;
-  await increaseTime(diff); //make sure period start has reached
   console.log("ubischeme start:", {
     now: now.timestamp,
     blockTime: lastBlock.timestamp,
@@ -658,6 +657,8 @@ export const deployUBI = async deployedDAO => {
     periodEnd: await ubiScheme.periodEnd().then(_ => _.toString()),
     diff
   });
+  if (diff > 0 && diff < 2 ** 64)
+    await increaseTime(diff); //make sure period start has reached
   const tx = await firstClaim.start();
   console.log("firstclaim started");
   await ubiScheme.start();