@gooddollar/goodprotocol 2.1.0 → 2.1.2

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

@@ -15,40 +15,30 @@
 // deploy distribution helper
 // transfer usdc to xdc reserve
 // update celo reserve parameters accordingly
+// upgrade celo's distribution helper to genericdistributionhelper (simulate it is working)
 
 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 {
+  executeViaGuardian,
+  executeViaSafe,
+  verifyContract,
+  verifyProductionSigner
+} from "../multichain-deploy/helpers";
 
 import dao from "../../releases/deployment.json";
-import {
-  CeloDistributionHelper,
-  Controller,
-  FuseOldBridgeKill,
-  GoodMarketMaker,
-  IBancorExchangeProvider,
-  IBroker,
-  IdentityV3,
-  IGoodDollar,
-  IGoodDollarExchangeProvider,
-  IGoodDollarExpansionController,
-  IMentoReserve,
-  IMessagePassingBridge,
-  ProtocolUpgradeV4Mento,
-  UBISchemeV2
-} from "../../types";
-import releaser from "../releaser";
+import { Controller, IdentityV3, IGoodDollar, IMessagePassingBridge, UBISchemeV2 } from "../../types";
+import { upgrade } from "./gip-15";
 let { name: networkName } = network;
 const isSimulation = network.name === "hardhat" || network.name === "fork" || network.name === "localhost";
 const bridgeUpgradeImpl = {
-  "production-celo": "0x7bDaF2Fb332761b2a6A565a43ccB0ACfC36d2C3D",
-  production: "0x6f252280eB53df085eAD27BBe55d615741A8268D",
-  "production-mainnet": "0x7baFe060A37E31E707b8B28a90a36731ee99aFBa"
+  "production-celo": "0xF3eAB7018d74E7Df95A5d8dC70987C0539bDF48f",
+  production: "0xFB62aA509a7B260b6697B671C969a184d6c39E90",
+  "production-mainnet": "0x12ab702f015D3302f3cc0c4AbA0626A127D06A07",
+  "production-xdc": "0xe4CFA18A3d0a7d77fAA42961ee943c9221d61937"
 };
 export const upgradeCeloStep1 = async (network, checksOnly) => {
   let [root] = await ethers.getSigners();
@@ -109,6 +99,15 @@ export const upgradeCeloStep1 = async (network, checksOnly) => {
       ethers.utils.defaultAbiCoder.encode(["address", "bytes"], [bridgeImpl, upgradeCall]),
       "0"
     ], //upgrade bridge
+    [
+      release.MpbBridge,
+      "setConfig(uint16,uint16,uint256,bytes)",
+      ethers.utils.defaultAbiCoder.encode(
+        ["uint16", "uint16", "uint256", "bytes"],
+        [0, 365, 5, "0x000000000000000000000000000000000000000000000000000000000000000f"]
+      ),
+      "0"
+    ], //fix xdc bridge setting of outbound blocks confirmations
     [
       release.MpbBridge,
       "withdraw(address,uint256)",
@@ -160,10 +159,9 @@ export const upgradeCeloStep1 = async (network, checksOnly) => {
   }
 
   if (isSimulation || !isProduction) {
-    const supplyAfter = await (await ethers.getContractAt("IGoodDollar", release.GoodDollar)).totalSupply();
-    const bridgeBalanceAfter = await (
-      await ethers.getContractAt("IGoodDollar", release.GoodDollar)
-    ).balanceOf(release.MpbBridge);
+    const gd = await ethers.getContractAt("IGoodDollar", release.GoodDollar);
+    const supplyAfter = await gd.totalSupply();
+    const bridgeBalanceAfter = await gd.balanceOf(release.MpbBridge);
     console.log("Bridge balance after upgrade:", { bridgeBalanceAfter });
     console.log("Supply after upgrade:", { supplyAfter });
 
@@ -182,6 +180,297 @@ export const upgradeCeloStep1 = async (network, checksOnly) => {
     console.log("UBI claim from connected account tx:", claimTx.events);
   }
 };
+export const upgradeCeloFix = 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 toBurn = "5515965554075495700269228267";
+  const proposalActions = [
+    [release.MpbBridge, "upgradeTo(address)", ethers.utils.defaultAbiCoder.encode(["address"], [bridgeImpl]), "0"], //upgrade bridge
+    [release.GoodDollar, "burn(uint256)", ethers.utils.defaultAbiCoder.encode(["uint256"], [toBurn.toString()]), "0"] //burn locked supply on celo 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,
+      "celo",
+      { nonce: 5 }
+    );
+  } else if (!checksOnly) {
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkEnv
+    );
+  }
+};
+export const upgradeXdcFix = 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
+    );
+  }
+};
+export const upgradeFuseFix = 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,
+      "fuse"
+    );
+  } else if (!checksOnly) {
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkEnv
+    );
+  }
+};
+export const upgradeEthFix = 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 upgradeCall = ethers.utils.keccak256(ethers.utils.toUtf8Bytes("upgrade()")).substring(0, 10);
+
+  const proposalActions = [
+    [
+      release.MpbBridge,
+      "upgradeToAndCall(address,bytes)",
+      ethers.utils.defaultAbiCoder.encode(["address", "bytes"], [bridgeImpl, upgradeCall]),
+      "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",
+      { nonce: 15 }
+    );
+  } else if (!checksOnly) {
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkEnv
+    );
+  }
+
+  if (isSimulation || !isProduction) {
+    const ctrl = (await ethers.getContractAt("Controller", release.Controller)) as Controller;
+    const isMinterScheme = await ctrl.getSchemePermissions(release.MpbBridge, release.Avatar);
+    console.log("Bridge minter permissions on avatar:", isMinterScheme);
+    // check xdc chainid in bridge
+    const mpb = (await ethers.getContractAt("IMessagePassingBridge", release.MpbBridge)) as IMessagePassingBridge;
+    console.log("xdc lz chainid:", await mpb.toLzChainId(50));
+  }
+};
+
+export const verifyUpgradeCeloStep1 = async networkEnv => {
+  let release: { [key: string]: any } = dao[networkEnv];
+  const ctrl = (await ethers.getContractAt("Controller", release.Controller)) as Controller;
+  const isMinterScheme = await ctrl.getSchemePermissions(release.MpbBridge, release.Avatar);
+  console.log("Bridge minter permissions on avatar:", isMinterScheme);
+  // check xdc chainid in bridge
+  const mpb = (await ethers.getContractAt("IMessagePassingBridge", release.MpbBridge)) as IMessagePassingBridge;
+  console.log("xdc lz chainid:", await mpb.toLzChainId(50));
+  const gd = await ethers.getContractAt("IGoodDollar", release.GoodDollar);
+  const supplyAfter = await gd.totalSupply();
+  const bridgeBalanceAfter = await gd.balanceOf(release.MpbBridge);
+  const avatarBalanceAfter = await gd.balanceOf(release.Avatar);
+  console.log({ bridgeBalanceAfter, avatarBalanceAfter, supplyAfter });
+};
 
 export const upgradeFuseStep1 = async (network, checksOnly) => {
   let [root] = await ethers.getSigners();
@@ -231,7 +520,16 @@ export const upgradeFuseStep1 = async (network, checksOnly) => {
       "upgradeToAndCall(address,bytes)",
       ethers.utils.defaultAbiCoder.encode(["address", "bytes"], [bridgeImpl, upgradeCall]),
       "0"
-    ] //upgrade bridge
+    ], //upgrade bridge
+    [
+      release.MpbBridge,
+      "setConfig(uint16,uint16,uint256,bytes)",
+      ethers.utils.defaultAbiCoder.encode(
+        ["uint16", "uint16", "uint256", "bytes"],
+        [0, 365, 5, "0x000000000000000000000000000000000000000000000000000000000000000f"]
+      ),
+      "0"
+    ] //fix xdc bridge setting of outbound blocks confirmations
   ];
 
   console.log({
@@ -253,7 +551,7 @@ export const upgradeFuseStep1 = async (network, checksOnly) => {
       proposalFunctionSignatures,
       proposalFunctionInputs,
       release.GuardiansSafe,
-      "celo"
+      "fuse"
     );
   } else if (!checksOnly) {
     await executeViaGuardian(
@@ -341,7 +639,7 @@ export const upgradeEthStep1 = async (network, checksOnly) => {
       proposalFunctionSignatures,
       proposalFunctionInputs,
       release.GuardiansSafe,
-      "celo"
+      "mainnet"
     );
   } else if (!checksOnly) {
     await executeViaGuardian(
@@ -440,4 +738,9 @@ export const main = async () => {
   }
 };
 
-main().catch(console.log);
+// 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);

package/test/governance/ClaimersDistribution.test.ts

@@ -257,6 +257,6 @@ describe("ClaimersDistribution", () => {
       // console.log({ totalGas }, tx.gasUsed.toNumber(), tx2.gasUsed.toNumber());
     }
     console.log(Object.keys(gasCosts));
-    expect(totalGas / 30).lt(315000);
+    expect(totalGas / 30).lt(316000);
   });
 });