@gooddollar/goodprotocol 2.0.34-beta.2 → 2.0.34-beta.4

package/scripts/proposals/gip-25-xdc-upgrade.ts

@@ -0,0 +1,438 @@
+// Part 1 UBI+Bridge
+// deploy dao to xdc - Done
+// deploy bridge to xdc - Done
+// give minting rights to xdc bridge
+// upgrade to improved identity + ubischeme on celo + fuse
+// upgrade bridge on celo/ethereum/fuse - make sure they include xdc
+// burn celo bridge locked supply (now each chain has its own supply and all bridges are mint/burn)
+
+// Part 2 Reserve
+// create uniswap pools on xdc
+// calculate how much G$s each reserve is backing
+// deploy mento reserve to xdc with calculated parameters
+// give mento broker minting rights on xdc
+// deploy distribution helper
+// transfer usdc to xdc reserve
+// update celo reserve parameters accordingly
+
+import { network, ethers, upgrades } from "hardhat";
+import { reset } from "@nomicfoundation/hardhat-network-helpers";
+import { defaultsDeep, last } from "lodash";
+import prompt from "prompt";
+
+import { executeViaGuardian, executeViaSafe, verifyProductionSigner } from "../multichain-deploy/helpers";
+
+import ProtocolSettings from "../../releases/deploy-settings.json";
+
+import dao from "../../releases/deployment.json";
+import {
+  CeloDistributionHelper,
+  Controller,
+  FuseOldBridgeKill,
+  GoodMarketMaker,
+  IBancorExchangeProvider,
+  IBroker,
+  IGoodDollar,
+  IGoodDollarExchangeProvider,
+  IGoodDollarExpansionController,
+  IMentoReserve,
+  ProtocolUpgradeV4Mento
+} from "../../types";
+import releaser from "../releaser";
+let { name: networkName } = network;
+const isSimulation = network.name === "hardhat" || network.name === "fork" || network.name === "localhost";
+
+export const upgradeCelo = async (network, checksOnly) => {
+  let [root] = await ethers.getSigners();
+
+  const isProduction = networkName.includes("production");
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let networkEnv = networkName;
+  if (isSimulation) networkEnv = network;
+
+  let release: { [key: string]: any } = dao[networkEnv];
+
+  let guardian = root;
+  console.log("signer:", root.address, { networkEnv, isSimulation, isProduction, release });
+
+  const cusd = await ethers.getContractAt("IERC20", release.CUSD);
+  const gd = await ethers.getContractAt("GoodDollar", release.GoodDollar);
+  const mentoReserve = (await ethers.getContractAt("IMentoReserve", release.MentoReserve)) as IMentoReserve;
+
+  const ubiImpl = await ethers.deployContract("UBISchemeV2");
+  const identityImpl = await ethers.deployContract("IdentityV3");
+
+  console.log("deployed new impls", { ubiImpl: ubiImpl.address, identityImpl: identityImpl.address });
+
+  const proposalActions = [
+    [release.UBIScheme, "upgradeTo(address)", ethers.utils.defaultAbiCoder.encode(["address"], [ubiImpl.address]), "0"], //upgrade ubi
+    [
+      release.Identity,
+      "upgradeTo(address)",
+      ethers.utils.defaultAbiCoder.encode(["address"], [identityImpl.address]),
+      "0"
+    ] //upgrade identity
+  ];
+  const mentoExchange = (await ethers.getContractAt(
+    "IBancorExchangeProvider",
+    release.MentoExchangeProvider
+  )) as IBancorExchangeProvider;
+
+  //simulate on fork, make sure safe has enough eth to simulate txs
+  let DIST_HELPER_MIN_CELO_BALANCE = ethers.utils.parseEther("2");
+
+  if (isSimulation && !checksOnly) {
+    DIST_HELPER_MIN_CELO_BALANCE = ethers.utils.parseEther("0.1");
+    // await reset("https://rpc.ankr.com/celo");
+    await root.sendTransaction({ value: ethers.utils.parseEther("0.5"), to: release.Avatar });
+
+    const avatar = await ethers.getImpersonatedSigner(release.Avatar);
+    const reserveOwner = await ethers.getImpersonatedSigner(await mentoReserve.owner());
+    const eids = await mentoExchange.getExchangeIds();
+    if (eids.length > 0) {
+      await mentoExchange.connect(avatar).destroyExchange(eids[0], 0);
+    }
+
+    const devCUSD = await ethers.getContractAt(
+      [
+        "function mint(address,uint) external returns (uint)",
+        "function setValidators(address) external",
+        "function owner() view returns(address)"
+      ],
+      release.CUSD
+    );
+
+    console.log("minting devCUSD");
+    const cusdOwner = await ethers.getImpersonatedSigner(await devCUSD.owner());
+    await root.sendTransaction({ value: ethers.utils.parseEther("0.5"), to: cusdOwner.address });
+    await devCUSD.connect(cusdOwner).setValidators(release.Avatar).catch(console.log);
+    await devCUSD.connect(avatar).mint(root.address, ethers.utils.parseEther("2000000")).catch(console.log);
+
+    console.log("transfering cusd to reserve");
+    await cusd.connect(root).transfer(release.MentoReserve, ethers.utils.parseEther("200000"));
+
+    guardian = await ethers.getImpersonatedSigner(release.GuardiansSafe);
+    await root.sendTransaction({ value: ethers.utils.parseEther("0.5"), to: guardian.address });
+  } else if (!isProduction && !checksOnly) {
+    DIST_HELPER_MIN_CELO_BALANCE = ethers.utils.parseEther("0.1");
+    const mentoReserve = (await ethers.getContractAt("IMentoReserve", release.MentoReserve)) as IMentoReserve;
+    const ctrl = (await ethers.getContractAt("Controller", release.Controller)) as Controller;
+
+    const eids = await mentoExchange.getExchangeIds();
+    if (eids.length > 0) {
+      await (
+        await ctrl.genericCall(
+          mentoExchange.address,
+          mentoExchange.interface.encodeFunctionData("destroyExchange", [eids[0], 0]),
+          release.Avatar,
+          0
+        )
+      ).wait();
+    }
+
+    const devCUSD = await ethers.getContractAt(
+      ["function mint(address,uint) external returns (uint)", "function setValidators(address) external"],
+      release.CUSD
+    );
+    await (
+      await ctrl.genericCall(
+        devCUSD.address,
+        devCUSD.interface.encodeFunctionData("setValidators", [release.Avatar]),
+        release.Avatar,
+        0
+      )
+    ).wait();
+    await (
+      await ctrl.genericCall(
+        devCUSD.address,
+        devCUSD.interface.encodeFunctionData("mint", [root.address, ethers.utils.parseEther("2000000")]),
+        release.Avatar,
+        0
+      )
+    ).wait();
+
+    if ((await cusd.balanceOf(release.MentoReserve)).lt(ethers.utils.parseEther("200000"))) {
+      await cusd.transfer(release.MentoReserve, ethers.utils.parseEther("200000"));
+    }
+  }
+
+  const mpbImplementation = mpbDeployments["42220"].find(_ => _.name === "celo")["MessagePassingBridge_Implementation"]
+    .address;
+  const bridgeLocked = ["0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5", "0xD5D11eE582c8931F336fbcd135e98CEE4DB8CCB0"];
+  const locked = [
+    "0xD17652350Cfd2A37bA2f947C910987a3B1A1c60d",
+    "0xeC577447D314cf1e443e9f4488216651450DBE7c",
+    "0x6738fA889fF31F82d9Fe8862ec025dbE318f3Fde"
+  ];
+
+  const ethprovider = new ethers.providers.JsonRpcProvider("https://rpc.flashbots.net");
+  const fuseprovider = new ethers.providers.JsonRpcProvider("https://rpc.fuse.io");
+  const TOTAL_LOCKED = (
+    await Promise.all(
+      locked
+        .concat(bridgeLocked)
+        .map(_ => gd.connect(ethprovider).attach(dao["production-mainnet"].GoodDollar).balanceOf(_))
+    )
+  ).reduce((prev, cur) => prev.add(cur), ethers.constants.Zero);
+  const TOTAL_SUPPLY_ETH = await gd.connect(ethprovider).attach(dao["production-mainnet"].GoodDollar).totalSupply();
+  const TOTAL_SUPPLY_FUSE = await gd.connect(fuseprovider).attach(dao["production"].GoodDollar).totalSupply();
+  const TOTAL_SUPPLY_CELO = await gd.totalSupply();
+  const TOTAL_GLOBAL_SUPPLY = TOTAL_SUPPLY_ETH.add(TOTAL_SUPPLY_FUSE)
+    .sub(TOTAL_LOCKED)
+    .mul(ethers.BigNumber.from("10000000000000000")) //convert to 18 decimals
+    .add(TOTAL_SUPPLY_CELO);
+
+  const exchangeParams = [release.CUSD, release.GoodDollar, 0, 0, 0, 0]; //address reserveAsset;address tokenAddress;uint256 tokenSupply;uint256 reserveBalance;uint32 reserveRatio;uint32 exitConribution;
+
+  console.log({
+    networkEnv,
+    mpbImplementation,
+    guardian: guardian.address,
+    isSimulation,
+    isProduction,
+    release,
+    TOTAL_GLOBAL_SUPPLY
+  });
+
+  const mentoUpgrade = release.MentoUpgradeHelper
+    ? ((await ethers.getContractAt("ProtocolUpgradeV4Mento", release.MentoUpgradeHelper)) as ProtocolUpgradeV4Mento)
+    : await ethers.deployContract("ProtocolUpgradeV4Mento", [release.Avatar]);
+  let distHelper = release.CeloDistributionHelper
+    ? ((await ethers.getContractAt("CeloDistributionHelper", release.CeloDistributionHelper)) as CeloDistributionHelper)
+    : ((await upgrades.deployProxy(
+        await ethers.getContractFactory("CeloDistributionHelper"),
+        [release.NameService, "0x00851A91a3c4E9a4c1B48df827Bacc1f884bdE28"], //static oracle for uniswap
+        { initializer: "initialize" }
+      )) as CeloDistributionHelper);
+
+  release.MentoUpgradeHelper = mentoUpgrade.address;
+  release.CeloDistributionHelper = distHelper.address;
+  if (!isSimulation) {
+    releaser(release, networkEnv);
+  }
+  console.log("deployed mentoUpgrade", {
+    distribuitonHelper: distHelper.address,
+    mentoUpgrade: mentoUpgrade.address,
+    distHelperAvatar: await distHelper.avatar()
+  });
+
+  const proposalContracts = [
+    release.CeloDistributionHelper, //set fee settings
+    release.CeloDistributionHelper, //add ubi recipient
+    release.CeloDistributionHelper, //add community treasury recipient
+    release.MpbBridge, // upgrade
+    release.MpbBridge && release.GoodDollarMintBurnWrapper, // remove minting rights from bridge
+    release.GoodDollar, // set mento broker as minter
+    release.GoodDollar, // set reserve expansion controller as minter
+    release.Controller, // register upgrade contract
+    mentoUpgrade.address // create the exchange + set expansion rate
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "setFeeSettings((uint128,uint128,uint8,uint8))",
+    "addOrUpdateRecipient((uint32,uint32,address,uint8))",
+    "addOrUpdateRecipient((uint32,uint32,address,uint8))",
+    "upgradeTo(address)",
+    "revokeRole(bytes32,address)", // mpb is now lock/unlock doesnt need minting
+    "addMinter(address)",
+    "addMinter(address)",
+    "registerScheme(address,bytes32,bytes4,address)",
+    "upgrade(address,(address,address,uint256,uint256,uint32,uint32),address,address,address,uint256)" //Controller _controller,PoolExchange memory _exchange,address _mentoExchange,address _mentoController, address _distHelper
+  ];
+
+  console.log("preparing inputs...");
+  const proposalFunctionInputs = [
+    //uint128 maxFee;uint128 minBalanceForFees;uint8 percentageToSellForFee;
+    //2 celo max fee for lz bridge, min balance 2 celo, max percentage to sell 1%, max slippage 5%
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint128", "uint128", "uint8", "uint8"],
+      [ethers.utils.parseEther("2"), DIST_HELPER_MIN_CELO_BALANCE, "1", "5"]
+    ),
+    ethers.utils.defaultAbiCoder.encode(["uint32", "uint32", "address", "uint8"], [9000, 42220, release.UBIScheme, 1]), // ubi pool recipient
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "uint32", "address", "uint8"],
+      [1000, 42220, release.CommunitySafe, 1]
+    ), //community treasury recipient
+    ethers.utils.defaultAbiCoder.encode(["address"], [mpbImplementation]),
+    release.MpbBridge &&
+      ethers.utils.defaultAbiCoder.encode(
+        ["bytes32", "address"],
+        [ethers.utils.keccak256(ethers.utils.toUtf8Bytes("MINTER_ROLE")), release.MpbBridge]
+      ),
+    ethers.utils.defaultAbiCoder.encode(["address"], [release.MentoBroker]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [release.MentoExpansionController]),
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "bytes32", "bytes4", "address"],
+      [mentoUpgrade.address, ethers.constants.HashZero, "0x0000001f", release.Avatar]
+    ),
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "(address,address,uint256,uint256,uint32,uint32)", "address", "address", "address", "uint256"],
+      [
+        release.Controller,
+        exchangeParams,
+        release.MentoExchangeProvider,
+        release.MentoExpansionController,
+        release.CeloDistributionHelper,
+        TOTAL_GLOBAL_SUPPLY
+      ]
+    )
+  ];
+
+  console.log({ exchangeParams, mentoExchange: release.MentoExchangeProvider });
+  console.log("executing upgrade...", { proposalContracts, proposalFunctionInputs, proposalFunctionSignatures });
+
+  if (isProduction && !checksOnly) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      release.GuardiansSafe,
+      "celo"
+    );
+  } else if (!checksOnly) {
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkEnv
+    );
+  }
+
+  if (isSimulation || !isProduction) {
+    const swapper = networkEnv.includes("production")
+      ? await ethers.getImpersonatedSigner("0x66582D24FEaD72555adaC681Cc621caCbB208324")
+      : root;
+    const supplyAfter = await (await ethers.getContractAt("IGoodDollar", release.GoodDollar)).totalSupply();
+    console.log("Supply after upgrade:", { supplyAfter, TOTAL_GLOBAL_SUPPLY });
+
+    const isBrokerMinter = await gd.isMinter(release.MentoBroker);
+    const isExpansionMinter = await gd.isMinter(release.MentoExpansionController);
+    const mentoExchange = await ethers.getContractAt("IBancorExchangeProvider", release.MentoExchangeProvider);
+    const mentoBroker = (await ethers.getContractAt("IBroker", release.MentoBroker)) as IBroker;
+    const eids = await mentoExchange.getExchangeIds();
+    const exchange = await mentoExchange.getPoolExchange(eids[0]);
+    const price = (await mentoExchange.currentPrice(eids[0])) / 1e18;
+    console.log("current price:", price);
+    console.log("Exchange:", exchange, eids[0]);
+
+    console.log("Broker minter check:", isBrokerMinter ? "Success" : "Failed");
+    console.log("Expansion minter check:", isExpansionMinter ? "Success" : "Failed");
+
+    console.log("balance before swap:", await gd.balanceOf(swapper.address), await cusd.balanceOf(swapper.address));
+    await cusd.connect(swapper).approve(release.MentoBroker, ethers.utils.parseEther("1000"));
+    await mentoBroker
+      .connect(swapper)
+      .swapIn(mentoExchange.address, eids[0], cusd.address, gd.address, ethers.utils.parseEther("1000"), 0)
+      .then(_ => _.wait());
+    console.log(
+      "Balance after swap:",
+      swapper.address,
+      await gd.balanceOf(swapper.address),
+      await cusd.balanceOf(swapper.address)
+    );
+    const mentomint = (await ethers.getContractAt(
+      "IGoodDollarExpansionController",
+      release.MentoExpansionController
+    )) as IGoodDollarExpansionController;
+    await cusd.connect(swapper).approve(mentomint.address, ethers.utils.parseEther("1000"));
+    const tx = await (
+      await mentomint.connect(swapper).mintUBIFromInterest(eids[0], ethers.utils.parseEther("1000"))
+    ).wait();
+    console.log(
+      "mint from interest:",
+      tx.events.find(_ => _.event === "InterestUBIMinted").args.amount.toString() / 1e18
+    );
+    console.log("price after interest mint:", (await mentoExchange.currentPrice(eids[0])) / 1e18);
+    const distTx = await (await distHelper.onDistribution(0, { gasLimit: 2000000 })).wait();
+    const { distributionRecipients, distributed } = distTx.events.find(_ => _.event === "Distribution").args;
+    console.log("Distribution events:", distributionRecipients, distributed, distTx.events.length);
+    const bridgeBalance = await gd.balanceOf("0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5");
+    console.log("Brigde balance should equal other chains total supply:", {
+      bridgeBalance,
+      isEqual: bridgeBalance.eq(TOTAL_GLOBAL_SUPPLY.sub(TOTAL_SUPPLY_CELO))
+    });
+  }
+};
+
+const calculateReserveParams = async () => {
+  const celoProvider = new ethers.providers.JsonRpcProvider("https://forno.celo.org");
+  const gd = await ethers.getContractAt("GoodDollar", dao["production-celo"].GoodDollar);
+  const celoCusd = (await ethers.getContractAt("IERC20", dao["production-celo"].CUSD)).connect(celoProvider);
+  const gdCelo = gd.connect(celoProvider);
+  const totalSupplyCelo = await gdCelo.totalSupply();
+  const reserveBalance = await celoCusd.balanceOf(dao["production-celo"].MentoReserve);
+  const xdcReserveBalance = ethers.utils.parseUnits("200000", 18); //200k in xdc
+  const totalUSD = reserveBalance.add(xdcReserveBalance); //reserve + 200k in xdc
+  const xdcSupplyShare = xdcReserveBalance.mul(1e8).div(totalUSD);
+  const xdcGdSupplyEquivalent = totalSupplyCelo.mul(xdcSupplyShare).div(1e8);
+  const price = ethers.utils.parseUnits("0.00013", 8);
+  const celoGdSupplyEquivalent = totalSupplyCelo.sub(xdcGdSupplyEquivalent);
+
+  console.log({
+    totalSupplyCelo,
+    reserveBalance,
+    totalUSD,
+    xdcSupplyShare,
+    xdcGdSupplyEquivalent,
+    celoGdSupplyEquivalent
+  });
+
+  // uint32 reserveRatio = uint32(
+  // 		(cUSDBalance * 1e18 * 1e8) / (price * totalGlobalSupply)
+  // 	);
+  //calculate reserve ratio
+  const reserveRatioXdc = xdcReserveBalance
+    .mul(ethers.BigNumber.from("100000000")) //1e8
+    .mul(ethers.BigNumber.from("1000000000000000000")) //1e18
+    .div(xdcGdSupplyEquivalent.mul(price));
+  console.log(
+    "recommended reserve ratio for xdc:",
+    reserveRatioXdc.toString(),
+    reserveRatioXdc.div("10000000000").toNumber() / 1e8
+  );
+
+  //calcualte reserve ratio for celo
+  const reserveRatioCelo = reserveBalance
+    .mul(ethers.BigNumber.from("100000000")) //1e8
+    .mul(ethers.BigNumber.from("1000000000000000000")) //1e18
+    .div(celoGdSupplyEquivalent.mul(price));
+
+  console.log(
+    "recommended reserve ratio for celo:",
+    reserveRatioCelo.toString(),
+    reserveRatioCelo.div("10000000000").toNumber() / 1e8
+  );
+};
+
+export const main = async () => {
+  await calculateReserveParams();
+  return;
+  prompt.start();
+  const { network } = await prompt.get(["network"]);
+
+  console.log("running step:", { network });
+  const chain = last(network.split("-"));
+  switch (chain) {
+    case "mainnet":
+      //   await upgradeMainnet(network, true);
+
+      break;
+    case "fuse":
+      //   await upgradeFuse(network);
+
+      break;
+    case "celo":
+      await upgradeCelo(network, true);
+
+      break;
+  }
+};
+
+main().catch(console.log);

package/test/helpers.ts

@@ -525,7 +525,7 @@ export const deployUBI = async (deployedDAO, withFirstClaim = true) => {
 
   let ubiScheme = await upgrades.deployProxy(
     await ethers.getContractFactory("UBISchemeV2"),
-    [nameService.address],
+    [nameService.address, 1000],
     { kind: "uups" }
   );