@gooddollar/goodprotocol 1.0.2-beta.5 → 1.0.3-beta.2

package/scripts/upgradeToV2/upgradeToV2.ts

@@ -11,6 +11,7 @@ import { network, ethers, upgrades, run } from "hardhat";
 import { networkNames } from "@openzeppelin/upgrades-core";
 import { isFunction, get, omitBy } from "lodash";
 import { getImplementationAddress } from "@openzeppelin/upgrades-core";
+// import pressAnyKey from "press-any-key";
 import {
   AaveStakingFactory,
   CompoundStakingFactory,
@@ -32,7 +33,7 @@ import OldDAO from "../../releases/olddao.json";
 import ProtocolSettings from "../../releases/deploy-settings.json";
 import { keccak256 } from "@ethersproject/keccak256";
 
-const GAS_SETTINGS = {
+let GAS_SETTINGS: any = {
   maxPriorityFeePerGas: ethers.utils.parseUnits("1", "gwei"),
   maxFeePerGas: ethers.utils.parseUnits("50", "gwei"),
   gasLimit: 30000000
@@ -70,10 +71,17 @@ export const main = async (
   }
 
   const isProduction = networkName.startsWith("production");
-  if (isProduction) {
-    GAS_SETTINGS.gasLimit = 7000000;
-    GAS_SETTINGS.maxFeePerGas = ethers.utils.parseUnits("100", "gwei");
+  if (isProduction && networkName.includes("mainnet")) {
+    GAS_SETTINGS.gasLimit = 6000000;
+    GAS_SETTINGS.maxFeePerGas = ethers.utils.parseUnits("80", "gwei");
+  } else if (isProduction && !networkName.includes("mainnet")) {
+    //case we are on fusefuse
+    GAS_SETTINGS = {
+      gasLimit: 6000000,
+      gasPrice: ethers.utils.parseUnits("1", "gwei")
+    };
   }
+
   const isBackendTest = networkName.startsWith("dapptest");
   const isTest = network.name === "hardhat";
   const isCoverage = process.env.CODE_COVERAGE;
@@ -132,7 +140,7 @@ export const main = async (
     }
   ];
 
-  let release: { [key: string]: any } = {};
+  let release: { [key: string]: any } = newdao;
 
   const toDeployUpgradable = [
     {
@@ -207,7 +215,8 @@ export const main = async (
       name: "CompoundVotingMachine",
       args: [
         () => get(release, "NameService", newdao.NameService),
-        protocolSettings.governance.proposalVotingPeriod
+        protocolSettings.governance.proposalVotingPeriod,
+        protocolSettings.governance.guardian || root.address
       ]
     },
     {
@@ -303,14 +312,20 @@ export const main = async (
   let proxyFactory: ProxyFactory1967;
   const getProxyFactory = async () => {
     if (isDevelop === false && newdao.ProxyFactory) {
-      console.info("deploying ProxyFactory1967");
-      return (proxyFactory = ethers.getContractAt(
+      return (proxyFactory = (await ethers.getContractAt(
         "ProxyFactory1967",
         newdao.ProxyFactory
-      ) as unknown as ProxyFactory1967);
+      )) as unknown as ProxyFactory1967);
     } else {
+      console.info(
+        "deploying ProxyFactory1967",
+        isDevelop,
+        newdao.ProxyFactory
+      );
+      // await pressAnyKey();
+
       const pf = await (
-        await ethers.getContractFactory("ProxyFactory1967", proxyDeployer)
+        await ethers.getContractFactory("ProxyFactory1967", root)
       ).deploy(GAS_SETTINGS);
       await pf.deployed();
       await releaser(
@@ -340,6 +355,7 @@ export const main = async (
 
       if (contract.isUpgradable !== false) {
         if (isCoverage) {
+          console.log("Deploying:", contract.name, "using proxy");
           //coverage has large contracts doesnt work with proxy factory
           const tx = await upgrades.deployProxy(Contract, args, {
             initializer: contract.initializer,
@@ -349,6 +365,7 @@ export const main = async (
           await countTotalGas(tx, contract.name);
           return tx;
         }
+        console.log("Deploying:", contract.name, "using proxyfactory");
         const encoded = Contract.interface.encodeFunctionData(
           contract.initializer || "initialize",
           args
@@ -379,6 +396,7 @@ export const main = async (
       } else {
         //for some reason deploying with link library via proxy doesnt work on hardhat test env
         if (isTest === false) {
+          console.log("Deploying:", contract.name, "using proxyfactory code");
           const constructor = Contract.interface.encodeDeploy(args);
           const bytecode = ethers.utils.solidityPack(
             ["bytes", "bytes"],
@@ -396,6 +414,7 @@ export const main = async (
             )
           );
         } else {
+          console.log("Deploying:", contract.name, "using regular");
           const tx = await Contract.deploy(...args, GAS_SETTINGS);
           await countTotalGas(tx, contract.name);
           const impl = await tx.deployed();
@@ -446,6 +465,7 @@ export const main = async (
         // release
         // pf: ProxyFactory.factory.address
       });
+      // await pressAnyKey();
       let opts = {};
       if (contract.libraries) {
         let libraries = {};
@@ -457,12 +477,21 @@ export const main = async (
       let deployed = await deployDeterministic(contract, args, opts);
 
       console.log(`${contract.name} deployed to: ${deployed.address}`);
-      await releaser(release, networkName, "deployment", false);
       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
+      });
     }
 
-    const { DonationsStaking, StakingContracts } =
-      isMainnet && (await deployStakingContracts(release));
     release["network"] = networkName;
     release["networkId"] = network.config.chainId || 4447;
     if (!isMainnet) {
@@ -475,8 +504,7 @@ export const main = async (
       release["ForeignBridge"] = dao.ForeignBridge;
       release["Contribution"] = dao.Contribution;
     }
-    release["StakingContracts"] = StakingContracts;
-    release["DonationsStaking"] = DonationsStaking;
+
     release["Identity"] = dao.Identity;
     release["GoodDollar"] = dao.GoodDollar;
     release["Controller"] = dao.Controller;
@@ -489,10 +517,6 @@ export const main = async (
     release["cDAI"] = get(protocolSettings, "compound.cdai", dao.cDAI);
     release["COMP"] = get(protocolSettings, "compound.comp", dao.COMP);
 
-    console.log("staking contracts result:", {
-      StakingContracts,
-      DonationsStaking
-    });
     release = omitBy(release, _ => _ === undefined);
     let res = Object.assign(newdao, release);
     await releaser(release, networkName);
@@ -775,7 +799,8 @@ export const main = async (
           protocolSettings.staking.fullRewardsThreshold, //blocks before switching for 0.5x rewards to 1x multiplier
           token.usdOracle,
           token.compUsdOracle,
-          token.swapPath
+          token.swapPath,
+          GAS_SETTINGS
         )
       ).wait();
       await countTotalGas(tx, "deploy comp staking");
@@ -813,7 +838,8 @@ export const main = async (
               dao.AaveIncentiveController
             ),
             token.aaveUsdOracle,
-            token.swapPath
+            token.swapPath,
+            GAS_SETTINGS
           )
         ).wait();
         await countTotalGas(tx, "deploy aave staking");
@@ -873,22 +899,17 @@ export const main = async (
       ) {
         console.log(
           contract,
-          " Skipping non mainnet/sidechain contract:",
+          " Skipping verification 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;
-      }
+      console.log(
+        "Running contract verification:",
+        { contract },
+        release[contract.name]
+      );
       if (contract.isUpgradable !== false) {
         const implementationAddress = await getImplementationAddress(
           network.provider,
@@ -905,7 +926,10 @@ export const main = async (
         try {
           await run("verify:verify", {
             address: release[contract.name],
-            constructorArguments: contract.args
+            constructorArguments: contract.args,
+            libraries: {
+              UniswapV2SwapHelper: release["UniswapV2SwapHelper"]
+            }
           });
         } catch (err) {
           console.log("err", err);
@@ -933,7 +957,7 @@ export const main = async (
   // await proveNewRep();
 };
 if (network.name !== "hardhat") {
-  main(name)
+  main(name, false)
     .catch(e => {
       console.log(e);
       throw e;

package/test/governance/CompoundVotingMachine.castvote.test.ts

@@ -22,9 +22,6 @@ describe("CompoundVotingMachine#CastVote", () => {
 
   before(async () => {
     [root, acct, ...signers] = await ethers.getSigners();
-    const CompoundVotingMachine = await ethers.getContractFactory(
-      "CompoundVotingMachine"
-    );
 
     let {
       daoCreator,

package/test/governance/CompoundVotingMachine.daoscheme.ts

@@ -59,15 +59,6 @@ describe("CompoundVotingMachine#DAOScheme", () => {
   before(async () => {
     [root, acct, ...signers] = await ethers.getSigners();
 
-    // const GReputation = await ethers.getContractFactory("GReputation");
-    const CompoundVotingMachine = await ethers.getContractFactory(
-      "CompoundVotingMachine"
-    );
-
-    // grep = (await upgrades.deployProxy(GReputation, [root.address], {
-    //   unsafeAllowCustomTypes: true
-    // })) as GReputation;
-
     let {
       daoCreator,
       controller,

package/test/governance/CompoundVotingMachine.guardian.test.ts

@@ -50,10 +50,6 @@ describe("CompoundVotingMachine#Guardian", () => {
   before(async () => {
     [root, acct, ...signers] = await ethers.getSigners();
 
-    const CompoundVotingMachine = await ethers.getContractFactory(
-      "CompoundVotingMachine"
-    );
-
     let {
       daoCreator,
       controller,
@@ -94,6 +90,15 @@ describe("CompoundVotingMachine#Guardian", () => {
     mock.mock.rec.returns();
   });
 
+  it("should set guardian from initializer", async () => {
+    const votingMachine = (await upgrades.deployProxy(
+      await ethers.getContractFactory("CompoundVotingMachine"),
+      [nameService.address, 5760, signers[2].address],
+      { kind: "uups" }
+    )) as unknown as CompoundVotingMachine;
+    expect(await votingMachine.guardian()).to.equal(signers[2].address);
+  });
+
   it("Should have deployer as guardian", async () => {
     expect(await gov.guardian()).to.equal(root.address);
   });
@@ -146,7 +151,7 @@ describe("CompoundVotingMachine#Guardian", () => {
 
     const gov2 = (await upgrades.deployProxy(
       CompoundVotingMachine,
-      [nameService.address, 5760],
+      [nameService.address, 5760, root.address],
       { kind: "uups" }
     )) as CompoundVotingMachine;
 

package/test/governance/CompoundVotingMachine.propose.test.ts

@@ -22,9 +22,6 @@ describe("CompoundVotingMachine#propose", () => {
 
   before(async () => {
     [root, acct, ...signers] = await ethers.getSigners();
-    const CompoundVotingMachine = await ethers.getContractFactory(
-      "CompoundVotingMachine"
-    );
 
     let { avatar, reputation, setDAOAddress, nameService, votingMachine } =
       await createDAO();

package/test/governance/CompoundVotingMachine.state.test.ts

@@ -58,9 +58,6 @@ describe("CompoundVotingMachine#States", () => {
 
   before(async () => {
     [root, acct, ...signers] = await ethers.getSigners();
-    const CompoundVotingMachine = await ethers.getContractFactory(
-      "CompoundVotingMachine"
-    );
 
     let {
       setSchemes,

package/test/helpers.ts

@@ -19,7 +19,7 @@ import {
   GoodMarketMaker,
   CompoundVotingMachine,
   GoodCompoundStaking,
-  GoodAaveStaking,
+  GoodAaveStaking
 } from "../types";
 import { Contract } from "@ethersproject/contracts";
 import { BigNumber } from "@ethersproject/bignumber";
@@ -29,12 +29,12 @@ export const getStakingFactory = async (
 ) => {
   let swapHelper = await ethers
     .getContractFactory("UniswapV2SwapHelper")
-    .then((_) => _.deploy());
+    .then(_ => _.deploy());
 
   const simpleStakingFactory = await ethers.getContractFactory(factory, {
     libraries: {
-      UniswapV2SwapHelper: swapHelper.address,
-    },
+      UniswapV2SwapHelper: swapHelper.address
+    }
   });
   return simpleStakingFactory;
 };
@@ -96,7 +96,7 @@ export const createDAO = async () => {
     await daoCreator.avatar(),
     [
       "function owner() view returns (address)",
-      "function nativeToken() view returns (address)",
+      "function nativeToken() view returns (address)"
     ],
     root
   );
@@ -120,7 +120,7 @@ export const createDAO = async () => {
     contribution.address,
     BancorFormula.address,
     dai.address,
-    cDAI.address,
+    cDAI.address
   ]);
   const nameService = await upgrades.deployProxy(
     await ethers.getContractFactory("NameService"),
@@ -138,8 +138,8 @@ export const createDAO = async () => {
         "COMP",
         "UBISCHEME",
         "BRIDGE_CONTRACT",
-        "UBI_RECIPIENT",
-      ].map((_) => ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))),
+        "UBI_RECIPIENT"
+      ].map(_ => ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))),
       [
         controller,
         Avatar.address,
@@ -152,11 +152,11 @@ export const createDAO = async () => {
         COMP.address,
         root.address,
         root.address,
-        root.address,
-      ],
+        root.address
+      ]
     ],
     {
-      kind: "uups",
+      kind: "uups"
     }
   );
 
@@ -167,11 +167,11 @@ export const createDAO = async () => {
     [
       nameService.address,
       //check sample merkle tree generated by gdxAirdropCalculation.ts script
-      "0x26ef809f3f845395c0bc66ce1eea85146516cb99afd030e2085b13e79514e94c",
+      "0x26ef809f3f845395c0bc66ce1eea85146516cb99afd030e2085b13e79514e94c"
     ],
     {
       initializer: "initialize(address, bytes32)",
-      kind: "uups",
+      kind: "uups"
     }
   );
   console.log("deploying marketMaker...");
@@ -190,7 +190,7 @@ export const createDAO = async () => {
     [nameService.address, "", ethers.constants.HashZero, 0],
     {
       kind: "uups",
-      initializer: "initialize(address, string, bytes32, uint256)",
+      initializer: "initialize(address, string, bytes32, uint256)"
     }
   );
 
@@ -218,7 +218,7 @@ export const createDAO = async () => {
   const setDAOAddress = async (name, addr) => {
     const encoded = nameService.interface.encodeFunctionData("setAddress", [
       name,
-      addr,
+      addr
     ]);
 
     await ictrl.genericCall(nameService.address, encoded, Avatar.address, 0);
@@ -285,7 +285,7 @@ export const createDAO = async () => {
   );
   const votingMachine = (await upgrades.deployProxy(
     await ethers.getContractFactory("CompoundVotingMachine"),
-    [nameService.address, 5760],
+    [nameService.address, 5760, root.address],
     { kind: "uups" }
   )) as unknown as CompoundVotingMachine;
   return {
@@ -308,10 +308,10 @@ export const createDAO = async () => {
     cdaiAddress: cDAI.address,
     COMP,
     reputation: reputation.address,
-    votingMachine,
+    votingMachine
   };
 };
-export const deployUBI = async (deployedDAO) => {
+export const deployUBI = async deployedDAO => {
   let { nameService, setSchemes, genericCall, setDAOAddress } = deployedDAO;
   const fcFactory = new ethers.ContractFactory(
     FirstClaimPool.abi,
@@ -321,7 +321,7 @@ export const deployUBI = async (deployedDAO) => {
 
   console.log("deploying first claim...", {
     avatar: await nameService.getAddress("AVATAR"),
-    identity: await nameService.getAddress("IDENTITY"),
+    identity: await nameService.getAddress("IDENTITY")
   });
   const firstClaim = await fcFactory.deploy(
     await nameService.getAddress("AVATAR"),
@@ -330,7 +330,7 @@ export const deployUBI = async (deployedDAO) => {
   );
 
   console.log("deploying ubischeme and starting...", {
-    input: [nameService.address, firstClaim.address, 14],
+    input: [nameService.address, firstClaim.address, 14]
   });
 
   let ubiScheme = await upgrades.deployProxy(
@@ -354,7 +354,7 @@ export const deployUBI = async (deployedDAO) => {
   await genericCall(gd, encoded);
 
   encoded = firstClaim.interface.encodeFunctionData("setUBIScheme", [
-    ubiScheme.address,
+    ubiScheme.address
   ]);
 
   await genericCall(firstClaim.address, encoded);
@@ -365,7 +365,7 @@ export const deployUBI = async (deployedDAO) => {
   setDAOAddress("UBISCHEME", ubiScheme.address);
   return { firstClaim, ubiScheme };
 };
-export const deployOldUBI = async (deployedDAO) => {
+export const deployOldUBI = async deployedDAO => {
   let { nameService, setSchemes, genericCall, setDAOAddress } = deployedDAO;
   const fcFactory = new ethers.ContractFactory(
     FirstClaimPool.abi,
@@ -379,7 +379,7 @@ export const deployOldUBI = async (deployedDAO) => {
   );
   console.log("deploying first claim...", {
     avatar: await nameService.getAddress("AVATAR"),
-    identity: await nameService.getAddress("IDENTITY"),
+    identity: await nameService.getAddress("IDENTITY")
   });
   const firstClaim = await fcFactory.deploy(
     await nameService.getAddress("AVATAR"),
@@ -388,7 +388,7 @@ export const deployOldUBI = async (deployedDAO) => {
   );
 
   console.log("deploying ubischeme and starting...", {
-    input: [nameService.address, firstClaim.address, 14],
+    input: [nameService.address, firstClaim.address, 14]
   });
   const block = await ethers.provider.getBlock("latest");
   const startUBI = block.timestamp - 60 * 60 * 24 * 2;
@@ -439,7 +439,7 @@ export const advanceBlocks = async (blocks: number) => {
   }
 };
 
-export const deployOldVoting = async (dao) => {
+export const deployOldVoting = async dao => {
   try {
     const SchemeRegistrarF = new ethers.ContractFactory(
       SchemeRegistrar.abi,
@@ -460,7 +460,7 @@ export const deployOldVoting = async (dao) => {
     const [absoluteVote, upgradeScheme, schemeRegistrar] = await Promise.all([
       AbsoluteVoteF.deploy(),
       UpgradeSchemeF.deploy(),
-      SchemeRegistrarF.deploy(),
+      SchemeRegistrarF.deploy()
     ]);
     console.log("setting parameters");
     const voteParametersHash = await absoluteVote.getParametersHash(
@@ -477,7 +477,7 @@ export const deployOldVoting = async (dao) => {
         absoluteVote.address
       ),
       absoluteVote.setParameters(50, ethers.constants.AddressZero),
-      upgradeScheme.setParameters(voteParametersHash, absoluteVote.address),
+      upgradeScheme.setParameters(voteParametersHash, absoluteVote.address)
     ]);
     const upgradeParametersHash = await upgradeScheme.getParametersHash(
       voteParametersHash,
@@ -502,7 +502,7 @@ export const deployOldVoting = async (dao) => {
     return {
       schemeRegistrar,
       upgradeScheme,
-      absoluteVote,
+      absoluteVote
     };
   } catch (e) {
     console.log("deployVote failed", e);
@@ -565,7 +565,7 @@ export const deployUniswap = async (comp, dai) => {
   );
   console.log("depositing eth to liquidity pools");
   await weth.deposit({ value: ethers.utils.parseEther("4000") });
-  console.log(await weth.balanceOf(founder.address).then((_) => _.toString()));
+  console.log(await weth.balanceOf(founder.address).then(_ => _.toString()));
   await weth.transfer(compPair.address, ethers.utils.parseEther("2000"));
   await weth.transfer(daiPair.address, ethers.utils.parseEther("2000"));
   console.log("minting liquidity pools");
@@ -578,6 +578,6 @@ export const deployUniswap = async (comp, dai) => {
     factory,
     weth,
     compPairContract: compPair,
-    daiPairContract: daiPair,
+    daiPairContract: daiPair
   };
 };

package/test/ubi/UBIScheme.test.ts

@@ -478,10 +478,7 @@ describe("UBIScheme", () => {
     await ubi.connect(claimer2).claim();
     let claimer4BalanceAfter = await goodDollar.balanceOf(claimer2.address);
     expect(
-      ubiBalance
-        .add(avatarBalance)
-        .div(activeUsersCount)
-        .toNumber()
+      ubiBalance.add(avatarBalance).div(activeUsersCount).toNumber()
     ).to.be.equal(
       claimer4BalanceAfter.toNumber() - claimer4BalanceBefore.toNumber()
     );
@@ -498,18 +495,12 @@ describe("UBIScheme", () => {
     let claimer4BalanceAfter = await goodDollar.balanceOf(claimer2.address);
     let dailyUbi = await ubi.dailyUbi();
     expect(
-      ubiBalance
-        .add(avatarBalance)
-        .div(activeUsersCount)
-        .toNumber()
+      ubiBalance.add(avatarBalance).div(activeUsersCount).toNumber()
     ).to.be.equal(
       claimer4BalanceAfter.toNumber() - claimer4BalanceBefore.toNumber()
     );
     expect(
-      ubiBalance
-        .add(avatarBalance)
-        .div(activeUsersCount)
-        .toNumber()
+      ubiBalance.add(avatarBalance).div(activeUsersCount).toNumber()
     ).to.be.equal(dailyUbi.toNumber());
   });
 
@@ -553,16 +544,14 @@ describe("UBIScheme", () => {
     expect(res).to.be.true;
   });
 
-  it("should return the reward value for entitlement user", async () => {
+  it("should return the estimated claim value for entitlement user before anyone claimed", async () => {
     await increaseTime(ONE_DAY);
     await ubi.connect(claimer1).claim();
     await increaseTime(ONE_DAY);
     let amount = await ubi.connect(claimer1).checkEntitlement();
     let balance2 = await goodDollar.balanceOf(ubi.address);
-    let activeUsersCount = await ubi.activeUsersCount();
-    expect(amount.toString()).to.be.equal(
-      balance2.div(activeUsersCount).toString()
-    );
+    let estimated = await ubi.estimateNextDailyUBI();
+    expect(amount).to.be.equal(estimated);
   });
 
   it("should set the ubi claim amount by avatar", async () => {

package/test/ubi/UBISchemeCycle.test.ts

@@ -154,18 +154,18 @@ describe("UBIScheme cycle", () => {
 
     const cycleLength = await ubiScheme.cycleLength();
     const curDailyPool = await ubiScheme.dailyCyclePool();
-    console.log({ balance, cycleLength, curDailyPool });
 
     //verify new daily pool IS gonna be larger than current
     expect(balance.div(cycleLength)).to.be.gt(curDailyPool);
 
+    const estimated = await ubiScheme.estimateNextDailyUBI();
     await increaseTime(ONE_DAY); //make sure
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait();
-
     const cycleEvent = transaction.events.find(
       e => e.event === "UBICycleCalculated"
     );
-
+    const dailyUBI = await ubiScheme.dailyUbi();
+    expect(dailyUBI).to.eq(estimated); //the estimated before actual calculation should be correct, ie equal to actual dailyUBI calculated after first claim.
     expect(cycleEvent).to.be.not.empty;
     expect(cycleEvent.args.day.toNumber()).to.be.a("number");
     expect(cycleEvent.args.pool).to.be.equal(balance);
@@ -183,7 +183,6 @@ describe("UBIScheme cycle", () => {
     let balance = await goodDollar.balanceOf(ubiScheme.address);
     const curCycleLen = await ubiScheme.cycleLength();
     const curDailyPool = await ubiScheme.dailyCyclePool();
-    console.log({ balance, curCycleLen, curDailyPool });
     //verify new daily pool is not gonna be larger than current
     expect(balance.div(curCycleLen)).to.be.lt(curDailyPool);
 

package/test/utils/ProtocolUpgrade.test.ts

@@ -17,6 +17,7 @@ export const BLOCK_INTERVAL = 1;
 describe("ProtocolUpgrade - Upgrade old protocol contracts to new ones", () => {
   let avatar,
     fuseAvatar,
+    deployment,
     dai,
     cDAI,
     signers,
@@ -186,7 +187,7 @@ describe("ProtocolUpgrade - Upgrade old protocol contracts to new ones", () => {
       oldDonationsStaking
     );
     const fse = require("fs-extra");
-    const deployment = await fse.readJson("releases/deployment.json");
+    deployment = await fse.readJson("releases/deployment.json");
     console.log("got deployment json file");
     cdaiBalanceOfNewReserve = await cDAI.balanceOf(
       deployment["test-mainnet"].GoodReserveCDai
@@ -399,6 +400,23 @@ describe("ProtocolUpgrade - Upgrade old protocol contracts to new ones", () => {
     expect(isUpgradeSchemeRegisteredAfterUpgradeFuse).to.be.equal(false);
     expect(isCompoundVotingMachineRegisteredFuse).to.be.equal(true);
   });
+  it("should set guardian from settings", async () => {
+    const cvm = await ethers.getContractAt(
+      "CompoundVotingMachine",
+      deployment["test-mainnet"].CompoundVotingMachine
+    );
+    expect(await cvm.guardian()).to.equal(
+      "0x914dA3B2508634998d244059dAb5488D9bA1814f"
+    );
+    const fuseCVM = await ethers.getContractAt(
+      "CompoundVotingMachine",
+      deployment["test"].CompoundVotingMachine
+    );
+    expect(await fuseCVM.guardian()).to.equal(
+      "0x914dA3B2508634998d244059dAb5488D9bA1814f"
+    );
+  });
+
   it("it should set fuse nameservice variables properly", async () => {
     const fse = require("fs-extra");
     const deployment = await fse.readJson("releases/deployment.json");