@gooddollar/goodprotocol 2.1.0 → 2.1.2

package/scripts/proposals/gip-25-xdc-deploy-reserve.ts

@@ -0,0 +1,425 @@
+// Part 2 Reserve
+// upgrade bridge + identity on all networks
+// 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,
+  verifyContract,
+  verifyProductionSigner
+} from "../multichain-deploy/helpers";
+
+import dao from "../../releases/deployment.json";
+import { Controller, IdentityV3, IGoodDollar, IMessagePassingBridge, UBISchemeV2 } from "../../types";
+let { name: networkName } = network;
+const isSimulation = network.name === "hardhat" || network.name === "fork" || network.name === "localhost";
+const bridgeUpgradeImpl = {
+  "production-celo": "0xF3eAB7018d74E7Df95A5d8dC70987C0539bDF48f",
+  production: "0xFB62aA509a7B260b6697B671C969a184d6c39E90",
+  "production-mainnet": "0x12ab702f015D3302f3cc0c4AbA0626A127D06A07",
+  "production-xdc": "0xe4CFA18A3d0a7d77fAA42961ee943c9221d61937"
+};
+export const upgradeCeloStep2 = async (network, checksOnly) => {
+  let [root] = await ethers.getSigners();
+
+  const isProduction = networkName.includes("production");
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let networkEnv = networkName;
+  let guardian = root;
+  if (isSimulation) {
+    networkEnv = network;
+  }
+
+  let release: { [key: string]: any } = dao[networkEnv];
+
+  console.log("signer:", root.address, { networkEnv, isSimulation, isProduction, release });
+
+  if (isSimulation) {
+    networkEnv = network;
+    guardian = await ethers.getImpersonatedSigner(release.GuardiansSafe);
+
+    await root.sendTransaction({
+      value: ethers.utils.parseEther("1"),
+      to: release.GuardiansSafe
+    });
+  }
+
+  const identityImpl = await ethers.deployContract("IdentityV3");
+  const reserveUpdate = await ethers.deployContract("UpdateReserveRatioAfterXDC")
+  const bridgeImpl = bridgeUpgradeImpl[networkEnv];
+
+  // Extract the first four bytes as the function selector
+  console.log("deployed new impls", { identityImpl: identityImpl.address });
+
+
+  const proposalActions = [
+    [
+      release.Identity,
+      "upgradeTo(address)",
+      ethers.utils.defaultAbiCoder.encode(["address"], [identityImpl.address]),
+      "0"
+    ], //upgrade identity
+    [
+      release.MpbBridge,
+      "upgradeTo(address)",
+      ethers.utils.defaultAbiCoder.encode(["address"], [bridgeImpl]),
+      "0"
+    ], //upgrade bridge
+    [
+      release.Controller,
+      "registerScheme(address,bytes32,bytes4,address)",
+      ethers.utils.defaultAbiCoder.encode(
+        ["address", "bytes32", "bytes4", "address"],
+        [reserveUpdate.address, ethers.constants.HashZero, "0x0000001f", release.Avatar]
+      ),
+      "0"
+    ] //give generic call rights to update reserve ratio
+
+  ];
+
+  console.log({
+    networkEnv,
+    guardian: guardian.address,
+    isSimulation,
+    isProduction,
+    release
+  });
+
+  const proposalContracts = proposalActions.map(a => a[0]);
+  const proposalFunctionSignatures = proposalActions.map(a => a[1]);
+  const proposalFunctionInputs = proposalActions.map(a => a[2]);
+  const proposalEthValues = proposalActions.map(a => a[3]);
+  if (isProduction && !checksOnly) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      release.GuardiansSafe,
+      "celo"
+    );
+  } else if (!checksOnly) {
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkEnv
+    );
+  }
+
+};
+
+export const upgradeFuseStep2 = async (network, checksOnly) => {
+  let [root] = await ethers.getSigners();
+
+  const isProduction = networkName.includes("production");
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let networkEnv = networkName;
+  let guardian = root;
+  if (isSimulation) {
+    networkEnv = network;
+  }
+
+  let release: { [key: string]: any } = dao[networkEnv];
+
+  console.log("signer:", root.address, { networkEnv, isSimulation, isProduction, release });
+
+  if (isSimulation) {
+    networkEnv = network;
+    guardian = await ethers.getImpersonatedSigner(release.GuardiansSafe);
+
+    await root.sendTransaction({
+      value: ethers.utils.parseEther("1"),
+      to: release.GuardiansSafe
+    });
+  }
+
+  const identityImpl = await ethers.deployContract("IdentityV3");
+  const bridgeImpl = bridgeUpgradeImpl[networkEnv];
+
+  // Extract the first four bytes as the function selector
+  console.log("deployed new impls", { identityImpl: identityImpl.address });
+
+  const proposalActions = [
+    [
+      release.Identity,
+      "upgradeTo(address)",
+      ethers.utils.defaultAbiCoder.encode(["address"], [identityImpl.address]),
+      "0"
+    ], //upgrade identity
+    [
+      release.MpbBridge,
+      "upgradeTo(address)",
+      ethers.utils.defaultAbiCoder.encode(["address"], [bridgeImpl]),
+      "0"
+    ], //upgrade bridge    
+  ];
+
+  console.log({
+    networkEnv,
+    guardian: guardian.address,
+    isSimulation,
+    isProduction,
+    release
+  });
+
+  const proposalContracts = proposalActions.map(a => a[0]);
+  const proposalFunctionSignatures = proposalActions.map(a => a[1]);
+  const proposalFunctionInputs = proposalActions.map(a => a[2]);
+  const proposalEthValues = proposalActions.map(a => a[3]);
+  if (isProduction && !checksOnly) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      release.GuardiansSafe,
+      "fuse"
+    );
+  } else if (!checksOnly) {
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkEnv
+    );
+  }
+};
+
+export const upgradeEthStep2 = async (network, checksOnly) => {
+  let [root] = await ethers.getSigners();
+
+  const isProduction = networkName.includes("production");
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let networkEnv = networkName;
+  let guardian = root;
+  if (isSimulation) {
+    networkEnv = network;
+  }
+
+  let release: { [key: string]: any } = dao[networkEnv];
+
+  console.log("signer:", root.address, { networkEnv, isSimulation, isProduction, release });
+
+  if (isSimulation) {
+    networkEnv = network;
+    guardian = await ethers.getImpersonatedSigner(release.GuardiansSafe);
+
+    await root.sendTransaction({
+      value: ethers.utils.parseEther("1"),
+      to: release.GuardiansSafe
+    });
+  }
+
+  const bridgeImpl = bridgeUpgradeImpl[networkEnv];
+
+  const proposalActions = [
+    [
+      release.MpbBridge,
+      "upgradeTo(address)",
+      ethers.utils.defaultAbiCoder.encode(["address"], [bridgeImpl]),
+      "0"
+    ] //upgrade bridge
+  ];
+
+  console.log({
+    networkEnv,
+    guardian: guardian.address,
+    isSimulation,
+    isProduction,
+    release
+  });
+
+  const proposalContracts = proposalActions.map(a => a[0]);
+  const proposalFunctionSignatures = proposalActions.map(a => a[1]);
+  const proposalFunctionInputs = proposalActions.map(a => a[2]);
+  const proposalEthValues = proposalActions.map(a => a[3]);
+  if (isProduction && !checksOnly) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      release.GuardiansSafe,
+      "mainnet"
+    );
+  } else if (!checksOnly) {
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkEnv
+    );
+  }
+};
+
+export const upgradeXdcStep2 = async (network, checksOnly) => {
+  let [root] = await ethers.getSigners();
+
+  const isProduction = networkName.includes("production");
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let networkEnv = networkName;
+  let guardian = root;
+  if (isSimulation) {
+    networkEnv = network;
+  }
+
+  let release: { [key: string]: any } = dao[networkEnv];
+
+  console.log("signer:", root.address, { networkEnv, isSimulation, isProduction, release });
+
+  if (isSimulation) {
+    networkEnv = network;
+    guardian = await ethers.getImpersonatedSigner(release.GuardiansSafe);
+
+    await root.sendTransaction({
+      value: ethers.utils.parseEther("1"),
+      to: release.GuardiansSafe
+    });
+  }
+
+  const bridgeImpl = bridgeUpgradeImpl[networkEnv];
+  const proposalActions = [
+    [release.MpbBridge, "upgradeTo(address)", ethers.utils.defaultAbiCoder.encode(["address"], [bridgeImpl]), "0"] //upgrade bridge
+  ];
+
+  console.log({
+    networkEnv,
+    guardian: guardian.address,
+    isSimulation,
+    isProduction,
+    release
+  });
+
+  const proposalContracts = proposalActions.map(a => a[0]);
+  const proposalFunctionSignatures = proposalActions.map(a => a[1]);
+  const proposalFunctionInputs = proposalActions.map(a => a[2]);
+  const proposalEthValues = proposalActions.map(a => a[3]);
+  if (isProduction && !checksOnly) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      release.GuardiansSafe,
+      "xdc"
+    );
+  } else if (!checksOnly) {
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkEnv
+    );
+  }
+};
+
+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("-")) || "fuse";
+  console.log("detected chain:", chain, network);
+  switch (chain) {
+    case "mainnet":
+      await upgradeEthStep2(network, false);
+
+      break;
+    case "production":
+    case "fuse":
+      await upgradeFuseStep2(network, false);
+
+      break;
+    case "celo":
+      await upgradeCeloStep2(network, false);
+
+      break;
+  }
+};
+
+// upgradeCeloFix("production-celo", false).catch(console.log);
+// upgradeEthFix("production-mainnet", false).catch(console.log);
+upgradeFuseFix("production", false).catch(console.log);
+// upgradeXdcFix("production-xdc", false).catch(console.log);
+// verifyUpgradeCeloStep1("production-celo");
+// main().catch(console.log);