@gooddollar/goodprotocol 1.0.30-beta.2 → 1.0.30-beta.3

package/scripts/upgradeToV3/v3-fix.ts

@@ -0,0 +1,120 @@
+/***
+ * This script will deploy a fixed goodfundmanager that doenst disable staking contracts if rewards=0
+ * It will also then re submit the staking contracts
+ */
+
+import { network, ethers } from "hardhat";
+
+import {
+  executeViaGuardian,
+  executeViaSafe
+} from "../multichain-deploy/helpers";
+
+import releaser from "../releaser";
+import dao from "../../releases/deployment.json";
+const { name: networkName } = network;
+
+export const deployMainnet = async () => {
+  let [root, ...signers] = await ethers.getSigners();
+
+  let executionMethod = networkName === "localhost" ? "guardians" : "safe";
+
+  const networkKey =
+    networkName === "localhost" ? "production-mainnet" : networkName;
+  let release: { [key: string]: any } = dao[networkKey];
+
+  let safeOwner = new ethers.Wallet(
+    process.env.SAFEOWNER_PRIVATE_KEY || ethers.constants.HashZero,
+    ethers.provider
+  );
+
+  //test with guardians safe on hardhat mainnet fork
+  if (network.name === "localhost") {
+    root = await ethers.getImpersonatedSigner(
+      "0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec"
+    );
+    await signers[0].sendTransaction({
+      to: root.address,
+      value: ethers.constants.WeiPerEther
+    });
+  }
+
+  console.log("got signers:", {
+    networkName,
+    networkKey,
+    root: root.address,
+    safeOwner: safeOwner.address,
+    balance: await ethers.provider
+      .getBalance(root.address)
+      .then(_ => _.toString())
+  });
+
+  console.log("deploying goodfundmanager implementation");
+  const gfmImpl = await (
+    await ethers.getContractFactory("GoodFundManager")
+  ).deploy();
+
+  const proposalContracts = [
+    release.GoodFundManager, //Fundmanager -> upgrade to new version
+    release.GoodFundManager, //Fundmanager -> set staking rewards compound to 0
+    release.GoodFundManager //Fundmanager -> set staking rewards aave to 0
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "upgradeTo(address)",
+    "setStakingReward(uint32,address,uint32,uint32,bool)",
+    "setStakingReward(uint32,address,uint32,uint32,bool)"
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(["address"], [gfmImpl.address]), //upgradeTo(address)
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "address", "uint32", "uint32", "bool"],
+      [
+        "0",
+        "0x7b7246c78e2f900d17646ff0cb2ec47d6ba10754",
+        "14338692",
+        "4294967295",
+        false
+      ]
+    ), //setstakingrewards to 0
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "address", "uint32", "uint32", "bool"],
+      [
+        "0",
+        "0x3ff2d8eb2573819a9ef7167d2ba6fd6d31b17f4f",
+        "14338692",
+        "4294967295",
+        false
+      ]
+    ) //setstakingrewards to 0
+  ];
+
+  if (executionMethod === "safe") {
+    return executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      networkName === "localhost"
+        ? "0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec"
+        : release.GuardiansSafe,
+      safeOwner
+    );
+  } else {
+    return executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      root
+    );
+  }
+};
+
+export const main = async () => {
+  await deployMainnet().catch(console.log);
+};
+if (process.argv[1].includes("v3-fix")) main();

package/scripts/upgradeToV3/v3-upgrade.ts

@@ -0,0 +1,219 @@
+/***
+ * This script will deploy a reserve upgrade and the DistributionHelper so that some of the expansion can be allocated
+ * for non-ubi purposes
+ * Upgrade process:
+ * mainnet:
+ * - deploy reserve
+ * - deploy distributionHelper
+ * - create proposal that:
+ *  - upgrades the reserve
+ *  - sets the distributionHelper at reserve with the agreed bps
+ *  - add to the distributionHelper the contracts addresses to receive part of the UBI
+ */
+
+import { network, ethers } from "hardhat";
+
+import {
+  deployDeterministic,
+  printDeploy,
+  executeViaGuardian,
+  executeViaSafe
+} from "../multichain-deploy/helpers";
+
+import releaser from "../releaser";
+import dao from "../../releases/deployment.json";
+import {
+  CompoundVotingMachine,
+  DistributionHelper,
+  Controller,
+  NameService
+} from "../../types";
+const { name: networkName } = network;
+
+export const deployMainnet = async () => {
+  let [root, ...signers] = await ethers.getSigners();
+
+  let executionMethod = "safe";
+  let communitySafe = "0x5Eb5f5fE13d1D5e6440DbD5913412299Bc5B5564";
+
+  const networkKey =
+    networkName === "localhost" ? "production-mainnet" : networkName;
+  let release: { [key: string]: any } = dao[networkKey];
+
+  let safeOwner = new ethers.Wallet(
+    process.env.SAFEOWNER_PRIVATE_KEY || ethers.constants.HashZero,
+    ethers.provider
+  );
+  //test with guardians safe on hardhat mainnet fork
+  if (network.name === "localhost") {
+    root = await ethers.getImpersonatedSigner(
+      "0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec"
+    );
+    await signers[0].sendTransaction({
+      to: root.address,
+      value: ethers.constants.WeiPerEther
+    });
+  }
+
+  console.log("got signers:", {
+    networkName,
+    networkKey,
+    root: root.address,
+    safeOwner: safeOwner.address,
+    balance: await ethers.provider
+      .getBalance(root.address)
+      .then(_ => _.toString())
+  });
+
+  console.log("deploying reserve implementation");
+  const reserveImpl = await (
+    await ethers.getContractFactory("GoodReserveCDai")
+  ).deploy();
+
+  console.log("deploying DistributionHelper");
+
+  let DHelper: DistributionHelper;
+  if (!release.DistributionHelper) {
+    DHelper = (await deployDeterministic(
+      {
+        name: "DistributionHelper",
+        salt: "DistributionHelper",
+        isUpgradeable: true
+      },
+      [release.NameService]
+    ).then(printDeploy)) as DistributionHelper;
+
+    let torelease = {
+      DistributionHelper: DHelper.address
+    };
+
+    await releaser(torelease, networkName, "deployment", false);
+  } else {
+    DHelper = (await ethers.getContractAt(
+      "DistributionHelper",
+      release.DistributionHelper
+    )) as DistributionHelper;
+  }
+  DHelper;
+
+  const ns = (await ethers.getContractAt(
+    "NameService",
+    release.NameService
+  )) as NameService;
+
+  const proposalContracts = [
+    ns.address, //nameservice add DistributionHelper,MultiChainRouter,MultiChain AnyGoodDollar,
+    DHelper.address, //update addresses from nameservice
+    DHelper.address, //distribution helper -> add fuse community pool as recipient with 100%
+    release.GoodReserveCDai, //upgradeTo
+    release.GoodReserveCDai, //Reserve -> set distribution helper + non ubi bps
+    release.GoodReserveCDai, //Reserve -> set new decline rate
+    release.GoodFundManager, //Fundmanager -> set staking rewards compound to 0
+    release.GoodFundManager //Fundmanager -> set staking rewards aave to 0
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "setAddresses(bytes32[],address[])",
+    "updateAddresses()",
+    "addOrUpdateRecipient((uint32,uint32,address,uint8))",
+    "upgradeTo(address)",
+    "setDistributionHelper(address,uint32)",
+    "setReserveRatioDailyExpansion(uint256,uint256)",
+    "setStakingReward(uint32,address,uint32,uint32,bool)",
+    "setStakingReward(uint32,address,uint32,uint32,bool)"
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(
+      ["bytes32[]", "address[]"],
+      [
+        [
+          ethers.utils.keccak256(
+            ethers.utils.toUtf8Bytes("DISTRIBUTION_HELPER")
+          ),
+          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("MULTICHAIN_ROUTER")),
+          ethers.utils.keccak256(
+            ethers.utils.toUtf8Bytes("MULTICHAIN_ANYGOODDOLLAR")
+          )
+        ],
+        [DHelper.address, release.MultichainRouter, release.AnyGoodDollar]
+      ]
+    ), //setAddresses(bytes32[],address[])"
+    ethers.utils.defaultAbiCoder.encode([], []), //updateAddresses()
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "uint32", "address", "uint8"],
+      [
+        10000, //100% bps
+        122, //chainid
+        communitySafe, //recipient address,
+        0 //recipient type via fuse bridge
+      ]
+    ), //addOrUpdateRecipient((uint32,uint32,address,uint8))
+    ethers.utils.defaultAbiCoder.encode(["address"], [reserveImpl.address]), //upgradeTo(address)
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "uint32"],
+      [DHelper.address, 1000]
+    ), //setDistributionHelper(address,uint32)
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint256", "uint256"],
+      ["999554841771249", "1000000000000000"] //15% a year
+    ), //setReserveRatioDailyExpansion(uint,uint)
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "address", "uint32", "uint32", "bool"],
+      [
+        "0",
+        "0x7b7246c78e2f900d17646ff0cb2ec47d6ba10754",
+        "14338692",
+        "4294967295",
+        false
+      ]
+    ), //setstakingrewards to 0
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "address", "uint32", "uint32", "bool"],
+      [
+        "0",
+        "0x3ff2d8eb2573819a9ef7167d2ba6fd6d31b17f4f",
+        "14338692",
+        "4294967295",
+        false
+      ]
+    ) //setstakingrewards to 0
+  ];
+
+  //make sure rewards accumulated before we set them to 0
+  const staking = await ethers.getContractAt(
+    "SimpleStakingV2",
+    "0x7b7246c78e2f900d17646ff0cb2ec47d6ba10754"
+  );
+  (await staking.withdrawRewards()).wait();
+  staking.attach("0x3ff2d8eb2573819a9ef7167d2ba6fd6d31b17f4f");
+  (await staking.withdrawRewards()).wait();
+
+  if (executionMethod === "safe") {
+    return executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      networkName === "localhost"
+        ? "0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec"
+        : release.GuardiansSafe,
+      safeOwner
+    );
+  } else {
+    return executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      root
+    );
+  }
+};
+
+export const main = async () => {
+  await deployMainnet().catch(console.log);
+};
+if (process.argv[1].includes("v3-upgrade")) main();

package/scripts/upgrades/celo-deploy.ts

@@ -0,0 +1,6 @@
+/**
+ * 0. deploy 3_gdStaking, deploy 4_ubi
+ * 1. guardians vote send X% to celo ubi pool
+ * 2. guardians vote on celo set new GOOD distribution for gdstaking + claiming ubi
+ * 3. guardians vote on fuse set new GOOD distribution for gdstaking + claiming ubi
+ */

package/scripts/upgrades/identity-upgrade.ts

@@ -0,0 +1,153 @@
+/***
+ * Upgrade Plan:
+ * - deploy Identity (if on production)
+ * - give adminWallet admin permissions
+ * - revoke deployer permissions
+ * - replace pointers to old identity contract in:
+ *    - GoodDollar token
+ *    - NameService
+ */
+
+import { network, ethers } from "hardhat";
+import { Contract, Signer } from "ethers";
+import {
+  deployDeterministic,
+  printDeploy,
+  executeViaGuardian
+} from "../multichain-deploy/helpers";
+
+import releaser from "../../scripts/releaser";
+
+import dao from "../../releases/deployment.json";
+import { DistributionHelper, Controller, NameService } from "../../types";
+const { name: networkName } = network;
+
+export const upgrade = async () => {
+  let release: { [key: string]: any } = dao[networkName];
+  const isProduction = networkName.includes("production");
+
+  let [root, ...signers] = await ethers.getSigners();
+
+  console.log("got signers:", {
+    networkName,
+    root: root.address,
+    balance: await ethers.provider
+      .getBalance(root.address)
+      .then(_ => _.toString())
+  });
+
+  let Identity = await ethers.getContractAt("IdentityV2", release.Identity);
+  if (isProduction) {
+    console.log("deploying new identity on production");
+    Identity = (await deployDeterministic(
+      {
+        name: "IdentityV2",
+        salt: "Identity",
+        isUpgradeable: true
+      },
+      [root, release.Identity]
+    ).then(printDeploy)) as Contract;
+    let torelease = {
+      Identity: Identity.address,
+      IdentityOld: release.Identity
+    };
+
+    await releaser(torelease, networkName, "deployment", false);
+  }
+
+  await executeProposal(Identity.address);
+};
+
+const executeProposal = async (identityAddress: string) => {
+  console.log("executing identity proposal");
+  const isProduction = networkName.includes("production");
+  let release: { [key: string]: any } = dao[networkName];
+  identityAddress = identityAddress || release.Identity;
+
+  let [root] = await ethers.getSigners();
+  //on celo we dont need voting yet to deploy it.
+  //dev env dont use voting for test purposes
+  const proposer =
+    !networkName.includes("celo") &&
+    (isProduction || networkName.includes("staging"))
+      ? new ethers.Wallet(process.env.PROPOSER_KEY, ethers.provider)
+      : root; //need proposer with 0.3% of GOOD tokens
+
+  const ctrl = (await ethers.getContractAt(
+    "Controller",
+    release.Controller
+  )) as Controller;
+
+  const ns = (await ethers.getContractAt(
+    "NameService",
+    release.NameService
+  )) as NameService;
+
+  const GoodDollar = await ethers.getContractAt(
+    "IGoodDollar",
+    release.GoodDollar
+  );
+
+  const proposalContracts = [
+    GoodDollar.address, //controller -> set new identity in G$
+    ns.address //nameservice modify to new Identity
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "setIdentity(address)", //set Identity on GoodDollar token
+    "setAddress(string,address)" //set new identity address in nameservice
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(["address"], [identityAddress]),
+    ethers.utils.defaultAbiCoder.encode(
+      ["string", "address"],
+      ["IDENTITY", identityAddress]
+    )
+  ];
+
+  if (!isProduction && networkName != "staging") {
+    //on fuse staging also use voting for testing
+    console.log("upgrading via guardian...");
+
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      root
+    );
+  } else if (isProduction) {
+    console.log("creating proposal...");
+    //create proposal
+    const vm = await ethers.getContractAt(
+      "CompoundVotingMachine",
+      release.CompoundVotingMachine
+    );
+
+    await vm
+      .connect(proposer)
+      ["propose(address[],uint256[],string[],bytes[],string)"](
+        proposalContracts,
+        proposalEthValues,
+        proposalFunctionSignatures,
+        proposalFunctionInputs,
+        "upgrade identity"
+      )
+      .then(printDeploy);
+  }
+
+  const gdIdentity = await GoodDollar.identity();
+  const nsIdentity = await ns.getAddress("IDENTITY");
+  console.log({
+    nameService: nsIdentity == identityAddress,
+    gdIdentity: gdIdentity == identityAddress
+  });
+};
+
+export const main = async () => {
+  await upgrade().catch(console.log);
+};
+main();

package/scripts/{multichain-deploy → upgrades}/nonubiDistribution-deploy.ts

@@ -11,18 +11,15 @@
  *  - add to the distributionHelper the GoodDollarMintBurnWrapper contract address on fuse as recipient with 100% bps
  */
 
-import { network, ethers, upgrades, run } from "hardhat";
-import { Contract, Signer } from "ethers";
+import { network, ethers } from "hardhat";
 
 import {
   deployDeterministic,
   printDeploy,
   executeViaGuardian
-} from "./helpers";
+} from "../multichain-deploy/helpers";
 import releaser from "../releaser";
-import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
-import { deployWrapper } from "./multichainWrapper-deploy";
 import {
   CompoundVotingMachine,
   DistributionHelper,

package/scripts/upgrades/transferDaoToGuardians.ts

@@ -0,0 +1,80 @@
+/***
+ * give genericcall to gaurdian safe, unregister deployer as scheme
+ */
+import { network, ethers, upgrades, run } from "hardhat";
+import { defaultsDeep } from "lodash";
+
+import {
+  deployDeterministic,
+  deploySuperGoodDollar,
+  executeViaGuardian,
+  printDeploy,
+  verifyProductionSigner
+} from "../multichain-deploy/helpers";
+import releaser from "../releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { Controller } from "../../types";
+
+const main = async () => {
+  let protocolSettings = defaultsDeep(
+    {},
+    ProtocolSettings[network.name],
+    ProtocolSettings["default"]
+  );
+
+  let release: { [key: string]: any } = dao[network.name];
+  const isProduction = network.name.includes("production");
+
+  let [root] = await ethers.getSigners();
+  const daoOwner = root.address;
+  if (isProduction) verifyProductionSigner(root);
+
+  console.log("got signers:", {
+    network,
+    daoOwner,
+    root: root.address,
+    balance: await ethers.provider
+      .getBalance(root.address)
+      .then(_ => _.toString()),
+    release
+  });
+
+  if (isProduction) {
+    const ctrl = (await ethers.getContractAt(
+      "Controller",
+      release.Controller
+    )) as Controller;
+    await ctrl
+      .registerScheme(
+        protocolSettings.guardiansSafe,
+        ethers.constants.HashZero,
+        "0x0000001f",
+        release.Avatar
+      )
+      .then(printDeploy);
+    await ctrl.unregisterSelf(release.Avatar).then(printDeploy);
+  } else {
+    console.log("simulating transfer...");
+    const ctrl = (await ethers.getContractAt(
+      "Controller",
+      release.Controller
+    )) as Controller;
+    console.log(
+      "register safe result:",
+      await ctrl.callStatic.registerScheme(
+        protocolSettings.guardiansSafe,
+        ethers.constants.HashZero,
+        "0x0000001f",
+        release.Avatar
+      )
+    );
+
+    console.log(
+      "unregister result",
+      await ctrl.callStatic.unregisterSelf(release.Avatar)
+    );
+  }
+};
+
+main();