@gooddollar/goodprotocol 1.0.29-beta.4 → 1.0.29

package/scripts/multichain-deploy/{1_basicdao-deploy.ts → basicdao-deploy.ts}

@@ -6,19 +6,21 @@
  */
 import { network, ethers, upgrades, run } from "hardhat";
 import { Contract } from "ethers";
-import { defaultsDeep } from "lodash";
 // import DAOCreatorABI from "@gooddollar/goodcontracts/build/contracts/DaoCreatorGoodDollar.json";
 import DAOCreatorABI from "../../../GoodBootstrap/packages/contracts/build/contracts/DaoCreatorGoodDollarWithRep.json";
 // import IdentityABI from "@gooddollar/goodcontracts/build/contracts/Identity.json";
+import IdentityABI from "../../../GoodBootstrap/packages/contracts/build/contracts/IdentityWithOwner.json";
 import FeeFormulaABI from "@gooddollar/goodcontracts/build/contracts/FeeFormula.json";
-import AddFoundersABI from "@gooddollar/goodcontracts/build/contracts/AddFoundersGoodDollarWithRep.json";
+import AddFoundersABI from "@gooddollar/goodcontracts/contracts/build/contracts/AddFoundersGoodDollarWithRep.json";
 
 import { deployDeterministic } from "./helpers";
-import releaser from "../releaser";
+import releaser from "../../scripts/releaser";
 import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
 import { TransactionResponse } from "@ethersproject/providers";
 
+const { name } = network;
+
 const printDeploy = async (
   c: Contract | TransactionResponse
 ): Promise<Contract | TransactionResponse> => {
@@ -34,30 +36,22 @@ const printDeploy = async (
 };
 
 export const createDAO = async () => {
-  let protocolSettings = defaultsDeep(
-    {},
-    ProtocolSettings[network.name],
-    ProtocolSettings["default"]
-  );
-
-  let release: { [key: string]: any } = dao[network.name];
+  const fusedao = dao[network.name.split("-")[0]];
+  const protocolSettings = ProtocolSettings["production"];
+  let release: { [key: string]: any } = {};
 
-  let [root] = await ethers.getSigners();
-  const daoOwner = protocolSettings.guardiansSafe || root.address;
-  if (!daoOwner) throw new Error("missing DAO_OWNER owner in env");
+  let [root, ...signers] = await ethers.getSigners();
   //generic call permissions
   let schemeMock = root;
   const isMainnet = network.name.includes("main");
 
   console.log("got signers:", {
     network,
-    daoOwner,
     root: root.address,
     schemeMock: schemeMock.address,
     balance: await ethers.provider
       .getBalance(root.address)
-      .then(_ => _.toString()),
-    release
+      .then(_ => _.toString())
   });
 
   if (network.name.includes("production")) {
@@ -77,6 +71,11 @@ export const createDAO = async () => {
     root
   );
 
+  const IdentityFactory = new ethers.ContractFactory(
+    IdentityABI.abi,
+    IdentityABI.bytecode,
+    root
+  );
   const FeeFormulaFactory = new ethers.ContractFactory(
     FeeFormulaABI.abi,
     FeeFormulaABI.bytecode,
@@ -91,27 +90,24 @@ export const createDAO = async () => {
   const AddFounders = (await AddFoundersFactory.deploy().then(
     printDeploy
   )) as Contract;
+  // const AddFounders = await ethers.getContractAt(
+  //   AddFoundersABI.abi,
+  //   "0x6F1BAbfF5E119d61F0c6d8653d84E8B284B87091"
+  // );
 
-  const proxyFactory = await ethers.getContractAt(
-    "ProxyFactory1967",
-    release.ProxyFactory
-  );
-  const salt = ethers.BigNumber.from(
-    ethers.utils.keccak256(ethers.utils.toUtf8Bytes("NameService"))
-  );
-  const nameserviceFutureAddress = await proxyFactory[
-    "getDeploymentAddress(uint256,address)"
-  ](salt, root.address);
-  console.log("deploying identity", { nameserviceFutureAddress });
   const Identity = (await deployDeterministic(
     {
-      name: "IdentityV2",
-      salt: "Identity",
-      isUpgradeable: true
+      name: "Identity",
+      factory: IdentityFactory
     },
-    [daoOwner, ethers.constants.AddressZero]
+    [root.address]
   ).then(printDeploy)) as Contract;
 
+  // const Identity = await ethers.getContractAt(
+  //   IdentityABI.abi,
+  //   release.Identity
+  // );
+
   const daoCreator = await DAOCreatorFactory.deploy(AddFounders.address);
 
   const FeeFormula = (await deployDeterministic(
@@ -133,8 +129,8 @@ export const createDAO = async () => {
     ]
   ).then(printDeploy)) as Contract;
 
-  // console.log("setting identity auth period");
-  // await Identity.setAuthenticationPeriod(365).then(printDeploy);
+  console.log("setting identity auth period");
+  await Identity.setAuthenticationPeriod(365).then(printDeploy);
 
   console.log("creating dao");
   await daoCreator
@@ -160,9 +156,20 @@ export const createDAO = async () => {
     root
   );
 
+  // const Avatar = new ethers.Contract(
+  //   release.Avatar,
+  //   [
+  //     "function owner() view returns (address)",
+  //     "function nativeToken() view returns (address)"
+  //   ],
+  //   root
+  // );
+
+  await Identity.setAvatar(Avatar.address).then(printDeploy);
+
   console.log("Done deploying DAO, setting schemes permissions");
 
-  let schemes = [daoOwner, Identity.address];
+  let schemes = [process.env.DAO_OWNER, Identity.address];
 
   const gd = await Avatar.nativeToken();
 
@@ -184,30 +191,24 @@ export const createDAO = async () => {
     { name: "NameService", isUpgradeable: true },
     [
       controller,
-      ["CONTROLLER", "AVATAR", "IDENTITY", "GOODDOLLAR", "REPUTATION"].map(_ =>
+      ["CONTROLLER", "AVATAR", "IDENTITY", "GOODDOLLAR"].map(_ =>
         ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))
       ),
-      [controller, Avatar.address, Identity.address, gd, GReputation.address]
+      [controller, Avatar.address, Identity.address, gd]
     ]
   );
 
-  console.log("GRep nameservice:");
   await (await GReputation.updateDAO(NameService.address)).wait();
-  console.log("Identity nameservice:");
-
-  await Identity.initDAO(NameService.address).then(printDeploy);
-
+  console.log("GRep nameservice:");
   //verifications
   const Controller = await ethers.getContractAt("Controller", controller);
   const GoodDollar = await ethers.getContractAt("IGoodDollar", gd);
 
-  if (network.name.includes("production")) {
-    console.log("renouncing minting rights on production env");
-    await GoodDollar.renounceMinter().then(printDeploy);
-  }
+  await GoodDollar.renounceMinter().then(printDeploy);
+  await Identity.transferOwnership(process.env.DAO_OWNER).then(printDeploy);
 
   const daoOwnerDaoPermissions = await Controller.getSchemePermissions(
-    daoOwner,
+    process.env.DAO_OWNER,
     Avatar.address
   );
 
@@ -222,10 +223,8 @@ export const createDAO = async () => {
     GReputation.MINTER_ROLE(),
     Avatar.address
   );
-  const daoOwnerIsIdentityOwner = await Identity.hasRole(
-    ethers.constants.HashZero,
-    daoOwner
-  );
+  const daoOwnerIsIdentityOwner =
+    process.env.DAO_OWNER === (await Identity.owner());
 
   //try to modify DAO -> should not succeed
   await (await GReputation.updateDAO(ethers.constants.AddressZero)).wait();
@@ -244,21 +243,18 @@ export const createDAO = async () => {
   });
 
   release = {
-    // ProxyFactory: "0x99C22e78A579e2176311c736C4c9F0b0D5A47806",
+    ProxyFactory: "0x99C22e78A579e2176311c736C4c9F0b0D5A47806",
     GoodDollar: gd,
     Avatar: Avatar.address,
     Controller: controller,
     Identity: Identity.address,
     NameService: NameService.address,
-    GReputation: GReputation.address,
-    FeeFormula: FeeFormula.address,
-    DAOCreator: daoCreator.address,
-    AddFounders: AddFounders.address
+    GReputation: GReputation.address
   };
   await releaser(release, network.name, "deployment", false);
 };
 
-export const main = async () => {
+export const main = async (networkName = name) => {
   await createDAO().catch(console.log);
 };
 main();

package/scripts/multichain-deploy/{3_gdSavings-deploy.ts → gdSavings-deploy.ts}

@@ -19,13 +19,8 @@
 
 import { network, ethers, upgrades, run } from "hardhat";
 import { Contract, Signer } from "ethers";
-import { defaultsDeep } from "lodash";
 
-import {
-  deployDeterministic,
-  printDeploy,
-  executeViaGuardian
-} from "./helpers";
+import { deployDeterministic, printDeploy } from "./helpers";
 import releaser from "../../scripts/releaser";
 import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
@@ -38,16 +33,18 @@ import {
 } from "../../types";
 const { name: networkName } = network;
 
+const BLOCKS_PER_YEAR = (12 * 60 * 24 * 365).toString();
+const BLOCK_APY = "1000000007735630000";
+
 export const deploySidechain = async () => {
   const isProduction = networkName.includes("production");
   let release: { [key: string]: any } = dao[networkName];
-  let settings = defaultsDeep(
-    {},
-    ProtocolSettings[networkName],
-    ProtocolSettings["default"]
-  );
 
-  let [root] = await ethers.getSigners();
+  let [root, ...signers] = await ethers.getSigners();
+  const proposer =
+    networkName !== "fuse"
+      ? new ethers.Wallet(process.env.PROPOSER_KEY, ethers.provider)
+      : root; //need proposer with 0.3% of GOOD tokens
 
   console.log("got signers:", {
     networkName,
@@ -81,9 +78,9 @@ export const deploySidechain = async () => {
       },
       [
         release.NameService,
-        ethers.BigNumber.from(settings.savings.blockAPY),
-        ethers.BigNumber.from(settings.savings.blocksPerYear),
-        settings.savings.daysUntilUpgrade
+        ethers.BigNumber.from(BLOCK_APY),
+        ethers.BigNumber.from(BLOCKS_PER_YEAR),
+        networkName === "fuse" ? 7 : 30 //days until upgrade
       ]
     ).then(printDeploy)) as Contract;
 
@@ -98,32 +95,12 @@ export const deploySidechain = async () => {
       release.GoodDollarStaking
     );
   }
-  if (networkName.includes("production"))
-    return console.log(
-      "Skipping proposal/upgrade for production, need to perform manually"
-    );
-
-  await executeProposal(GDSavings.address, Wrapper.address);
-};
 
-const executeProposal = async (
-  savingsAddress: string,
-  wrapperAddress: string
-) => {
-  console.log("executing savings + wrapper proposal");
-  const isProduction = networkName.includes("production");
-  let release: { [key: string]: any } = dao[networkName];
-  savingsAddress = savingsAddress || release.GoodDollarStaking;
-  wrapperAddress = wrapperAddress || release.GoodDollarMintBurnWrapper;
-
-  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
+  //create proposal
+  const vm = (await ethers.getContractAt(
+    "CompoundVotingMachine",
+    release.CompoundVotingMachine
+  )) as CompoundVotingMachine;
 
   const ctrl = (await ethers.getContractAt(
     "Controller",
@@ -136,7 +113,7 @@ const executeProposal = async (
   )) as NameService;
 
   const proposalContracts = [
-    wrapperAddress, //MinterWrapper -> add GDSavings
+    Wrapper.address, //MinterWrapper -> add GDSavings
     ctrl.address, //controller -> add MinterWrapper as scheme
     ctrl.address, // controller -> add GDSavings as scheme
     ns.address //nameservice add MinterWrapper
@@ -145,10 +122,10 @@ const executeProposal = async (
   const proposalEthValues = proposalContracts.map(_ => 0);
 
   const proposalFunctionSignatures = [
-    "addMinter(address,uint256,uint256,uint32,uint256,uint256,uint32,bool)", //add gooddollarstaking as minter in gooddollarwrapper
-    "registerScheme(address,bytes32,bytes4,address)", //make sure gooddollarwrapper is a registered scheme so it can mint G$ tokens
-    "registerScheme(address,bytes32,bytes4,address)", //make sure gdsavings has generic call so it can perform the upgrade process
-    "setAddress(string,address)" //add gooddollarwrapper in nameservice
+    "addMinter(address,uint256,uint256,uint32,uint256,uint256,uint32,bool)",
+    "registerScheme(address,bytes32,bytes4,address)",
+    "registerScheme(address,bytes32,bytes4,address)",
+    "setAddress(string,address)"
   ];
 
   const proposalFunctionInputs = [
@@ -163,12 +140,12 @@ const executeProposal = async (
         "uint32",
         "bool"
       ],
-      [savingsAddress, 0, 0, 30, 0, 0, 0, true]
+      [GDSavings.address, 0, 0, 30, 0, 0, 0, true]
     ), //function addMinter(
     ethers.utils.defaultAbiCoder.encode(
       ["address", "bytes32", "bytes4", "address"],
       [
-        wrapperAddress, //scheme
+        Wrapper.address, //scheme
         ethers.constants.HashZero, //paramshash
         "0x00000001", //permissions - minimal
         release.Avatar
@@ -177,7 +154,7 @@ const executeProposal = async (
     ethers.utils.defaultAbiCoder.encode(
       ["address", "bytes32", "bytes4", "address"],
       [
-        savingsAddress, //scheme
+        GDSavings.address, //scheme
         ethers.constants.HashZero, //paramshash
         "0x000000f1", //permissions - genericcall
         release.Avatar
@@ -185,62 +162,71 @@ const executeProposal = async (
     ),
     ethers.utils.defaultAbiCoder.encode(
       ["string", "address"],
-      ["MINTBURN_WRAPPER", wrapperAddress]
+      ["MINTBURN_WRAPPER", Wrapper.address]
     )
   ];
 
-  if (!isProduction && networkName != "staging") {
-    //on fuse staging also use voting for testing
-    console.log("upgrading via guardian...");
-
-    await executeViaGuardian(
+  if (networkName === "fuse") {
+    return executeViaGuardian(
       proposalContracts,
       proposalEthValues,
       proposalFunctionSignatures,
       proposalFunctionInputs,
       root
     );
-  } else if (isProduction) {
-    console.log("creating proposal...");
-    //create proposal
-    const vm = (await ethers.getContractAt(
-      "CompoundVotingMachine",
-      release.CompoundVotingMachine
-    )) as CompoundVotingMachine;
-
-    await vm
-      .connect(proposer)
-      ["propose(address[],uint256[],string[],bytes[],string)"](
-        proposalContracts,
-        proposalEthValues,
-        proposalFunctionSignatures,
-        proposalFunctionInputs,
-        "https://discourse.gooddollar.org/t/gip-5-allocating-part-of-ubi-inflation-towards-g-savings-account/114/20"
-      )
-      .then(printDeploy);
   }
 
-  const Controller = await ethers.getContractAt(
-    "Controller",
-    release.Controller
-  );
-  const wrapperDaoPermissions = await Controller.getSchemePermissions(
-    wrapperAddress,
-    release.Avatar
-  );
-  const savingsDaoPermissions = await Controller.getSchemePermissions(
-    savingsAddress,
-    release.Avatar
-  );
-
-  console.log({
-    wrapperDaoPermissions,
-    savingsDaoPermissions
-  });
+  console.log("creating proposal...");
+  await vm
+    .connect(proposer)
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      "https://discourse.gooddollar.org/t/gip-5-allocating-part-of-ubi-inflation-towards-g-savings-account/114/20"
+    )
+    .then(printDeploy);
+};
+
+const executeViaGuardian = async (
+  contracts,
+  ethValues,
+  functionSigs,
+  functionInputs,
+  guardian: Signer
+) => {
+  let release: { [key: string]: any } = dao[networkName];
+  const ctrl = await (
+    await ethers.getContractAt("Controller", release.Controller)
+  ).connect(guardian);
+
+  for (let i = 0; i < contracts.length; i++) {
+    const contract = contracts[i];
+    console.log("executing:", contracts[i], functionSigs[i], functionInputs[i]);
+    const sigHash = ethers.utils
+      .keccak256(ethers.utils.toUtf8Bytes(functionSigs[i]))
+      .slice(0, 10);
+    const encoded = ethers.utils.solidityPack(
+      ["bytes4", "bytes"],
+      [sigHash, functionInputs[i]]
+    );
+    if (contract === ctrl.address) {
+      console.log("executing directly on controller:", sigHash, encoded);
+
+      await guardian
+        .sendTransaction({ to: contract, data: encoded })
+        .then(printDeploy);
+    } else {
+      console.log("executing genericCall:", sigHash, encoded);
+      await ctrl
+        .genericCall(contract, encoded, release.Avatar, ethValues[i])
+        .then(printDeploy);
+    }
+  }
 };
 
 export const main = async () => {
   await deploySidechain().catch(console.log);
-  // await executeProposal(undefined, undefined);
 };
 if (process.argv[1].includes("gdSavings")) main();

package/scripts/multichain-deploy/helpers.ts

@@ -1,5 +1,6 @@
 import { Contract, ContractFactory, Signer } from "ethers";
 import { network, ethers, upgrades, run } from "hardhat";
+import { Contract } from "ethers";
 import { TransactionResponse } from "@ethersproject/providers";
 import dao from "../../releases/deployment.json";
 

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

@@ -11,15 +11,18 @@
  *  - add to the distributionHelper the GoodDollarMintBurnWrapper contract address on fuse as recipient with 100% bps
  */
 
-import { network, ethers } from "hardhat";
+import { network, ethers, upgrades, run } from "hardhat";
+import { Contract, Signer } from "ethers";
 
 import {
   deployDeterministic,
   printDeploy,
   executeViaGuardian
-} from "../multichain-deploy/helpers";
+} from "./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/test/localOldDaoDeploy.ts

@@ -23,7 +23,6 @@ import FundManager from "@gooddollar/goodcontracts/stakingModel/build/contracts/
 import SimpleDAIStaking from "@gooddollar/goodcontracts/stakingModel/build/contracts/SimpleDAIStaking.json";
 import BridgeMock from "@gooddollar/goodcontracts/stakingModel/build/contracts/BridgeMock.json";
 import DonationsStaking from "@gooddollar/goodcontracts/upgradables/build/contracts/DonationsStaking.json";
-import AdminWalletABI from "@gooddollar/goodcontracts/build/contracts/AdminWallet.json";
 import OTPABI from "@gooddollar/goodcontracts/build/contracts/OneTimePayments.json";
 
 import releaser from "../releaser";
@@ -107,15 +106,9 @@ export const deploy = async (networkName = name, single = false) => {
 
 const deployAdminWallet = async dao => {
   const signers = await ethers.getSigners();
-  const adminWallet = await new ethers.ContractFactory(
-    AdminWalletABI.abi,
-    AdminWalletABI.bytecode,
-    signers[0]
-  ).deploy(
-    signers.slice(0, 10).map(_ => _.address),
-    ethers.utils.parseUnits("1000000", "gwei"),
-    4,
-    dao.identity
+  const adminWallet = await upgrades.deployProxy(
+    await ethers.getContractFactory("AdminWallet"),
+    [signers.slice(0, 20).map(_ => _.address), signers[0].address, dao.identity]
   );
 
   const id = await ethers.getContractAt("IIdentity", dao.identity);

package/test/helpers.ts

@@ -55,8 +55,11 @@ export const createDAO = async () => {
     root
   );
 
-  const IdentityFactory = await ethers.getContractFactory("IdentityV2");
-
+  const IdentityFactory = new ethers.ContractFactory(
+    IdentityABI.abi,
+    IdentityABI.bytecode,
+    root
+  );
   const FeeFormulaFactory = new ethers.ContractFactory(
     FeeFormulaABI.abi,
     FeeFormulaABI.bytecode,
@@ -72,16 +75,11 @@ export const createDAO = async () => {
     await ethers.getContractFactory("BancorFormula")
   ).deploy();
   const AddFounders = await AddFoundersFactory.deploy();
-  const Identity = await upgrades.deployProxy(
-    IdentityFactory,
-    [root.address, ethers.constants.AddressZero],
-    { kind: "uups" }
-  );
-
+  const Identity = await IdentityFactory.deploy();
   const daoCreator = await DAOCreatorFactory.deploy(AddFounders.address);
   const FeeFormula = await FeeFormulaFactory.deploy(0);
 
-  // await Identity.setAuthenticationPeriod(365);
+  await Identity.setAuthenticationPeriod(365);
   await daoCreator.forgeOrg(
     "GoodDollar",
     "G$",
@@ -102,7 +100,7 @@ export const createDAO = async () => {
     root
   );
 
-  // await Identity.setAvatar(Avatar.address);
+  await Identity.setAvatar(Avatar.address);
   const controller = await Avatar.owner();
 
   const ccFactory = new ethers.ContractFactory(
@@ -161,8 +159,6 @@ export const createDAO = async () => {
     }
   );
 
-  await Identity.initDAO(nameService.address);
-
   console.log("deploying reserve...");
   let goodReserve = await upgrades.deployProxy(
     await ethers.getContractFactory("GoodReserveCDai"),