@gooddollar/goodprotocol 2.0.25-beta.8 → 2.0.25

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

package/scripts/utils.ts

@@ -33,5 +33,18 @@ export const bulkLastAuth = async (accounts: Array<String>) => {
   const identityContract = new Contract("0x2F9C28de9e6d44b71B91b8BA337A5D82e308E7BE", Identity.abi);
   const calls = accounts.map(d => identityContract.lastAuthenticated(d));
   const result = await ethcallProvider.all(calls);
-  return Object.fromEntries(accounts.map((v, i) => [v, parseInt(result[i])]));
+  // console.log({ result });
+  const whitelisted = accounts.filter((v, i) => parseInt(result[i]));
+  return whitelisted;
+};
+
+export const bulkGetLastAuth = async (accounts: Array<String>) => {
+  setMulticallAddress(122, "0x3CE6158b7278Bf6792e014FA7B4f3c6c46fe9410");
+  setMulticallAddress(42220, "0x75F59534dd892c1f8a7B172D639FA854D529ada3");
+  const celoProvider = new ethers.providers.JsonRpcProvider("https://forno.celo.org");
+  const ethcallProvider = new Provider(celoProvider, 42220);
+  const identityContract = new Contract("0xC361A6E67822a0EDc17D899227dd9FC50BD62F42", Identity.abi);
+  const calls = accounts.map(d => identityContract.lastAuthenticated(d));
+  const result = await ethcallProvider.all(calls);
+  return result;
 };

package/test/governance/CompoundVotingMachine.daoscheme.ts

@@ -89,6 +89,9 @@ describe("CompoundVotingMachine#DAOScheme", () => {
     await grep.mint(acct.address, ethers.BigNumber.from("500000"));
 
     queuePeriod = await gov.queuePeriod().then(_ => _.toNumber());
+
+    //disable guardian
+    await gov.renounceGuardian()
   });
 
   ///cell 0 - votingPeriod blocks, 1 - quoromPercentage, 2 - proposalPercentage,3 - proposalMaxOperations, 4 - voting delay blocks, 5 - queuePeriod time

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

@@ -185,13 +185,13 @@ describe("CompoundVotingMachine#Guardian", () => {
 
     await gov
       .connect(signers[4])
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        targets,
-        values,
-        signatures,
-        callDatas,
-        "do nothing"
-      );
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "do nothing"
+    );
     let proposalId = await gov.latestProposalIds(signers[4].address);
     await advanceBlocks(1);
 
@@ -204,34 +204,89 @@ describe("CompoundVotingMachine#Guardian", () => {
     await grep.delegateTo(root.address); //delegate back our votes
   });
 
+  it("Should not be able to pass proposal without guardian approval", async () => {
+    let targets = [gov.address];
+    let values = ["0"];
+    let signatures = ["setGuardian(address)"];
+    let callDatas = [encodeParameters(["address"], [signers[1].address])];
+
+    await gov
+      .connect(root)
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "set guardian"
+    );
+    let proposalBlock = +(await ethers.provider.getBlockNumber());
+    let proposalId = await gov.latestProposalIds(root.address);
+    await advanceBlocks(1);
+    await gov.connect(root).castVote(proposalId, true);
+    await increaseTime(queuePeriod);
+    expect(states[await gov.state(proposalId)]).to.equal("Succeeded");
+
+    await expect(gov.execute(proposalId)).revertedWith(/not approved/);
+
+  })
+
   it("Should be able to pass proposal to change guardian", async () => {
-    console.log(
-      grep.address,
-      await grep.totalSupply().then(_ => _.toString()),
-      await (await grep.getVotes(root.address)).toString(),
-      await (await grep.balanceOfLocal(root.address)).toString(),
-      await gov.rep()
+    let targets = [gov.address];
+    let values = ["0"];
+    let signatures = ["setGuardian(address)"];
+    let callDatas = [encodeParameters(["address"], [signers[2].address])];
+
+    await gov
+      .connect(root)
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "set guardian"
     );
+    let proposalBlock = +(await ethers.provider.getBlockNumber());
+    let proposalId = await gov.latestProposalIds(root.address);
+    await advanceBlocks(1);
+    await gov.connect(root).castVote(proposalId, true);
+    await increaseTime(queuePeriod);
+    expect(states[await gov.state(proposalId)]).to.equal("Succeeded");
+
+    await gov.connect(signers[1]).approveProposal(proposalId)
+
+    await gov.execute(proposalId);
+    expect(states[await gov.state(proposalId)]).to.equal("Executed");
+
+    //acct should now have 1M after proposal minted rep
+    expect(await gov.guardian()).to.equal(signers[2].address);
+  });
+
+  it("Should be able to pass proposal without approval if no guardian set", async () => {
     let targets = [gov.address];
     let values = ["0"];
     let signatures = ["setGuardian(address)"];
     let callDatas = [encodeParameters(["address"], [signers[1].address])];
 
+    await gov.connect(signers[2]).renounceGuardian()
+
+    expect(await gov.guardian()).equal(ethers.constants.AddressZero)
+
     await gov
       .connect(root)
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        targets,
-        values,
-        signatures,
-        callDatas,
-        "set guardian"
-      );
-    let proposalBlock = +(await ethers.provider.getBlockNumber());
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      targets,
+      values,
+      signatures,
+      callDatas,
+      "set guardian"
+    );
+
     let proposalId = await gov.latestProposalIds(root.address);
     await advanceBlocks(1);
     await gov.connect(root).castVote(proposalId, true);
     await increaseTime(queuePeriod);
     expect(states[await gov.state(proposalId)]).to.equal("Succeeded");
+
     await gov.execute(proposalId);
     expect(states[await gov.state(proposalId)]).to.equal("Executed");