@gooddollar/goodprotocol 1.0.31-beta.0 → 2.0.1

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

@@ -6,21 +6,22 @@
  */
 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 DAOCreatorABI from "@gooddollar/goodcontracts/build/contracts/DaoCreatorGoodDollarWithTokens.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/contracts/build/contracts/AddFoundersGoodDollarWithRep.json";
 
-import { deployDeterministic } from "./helpers";
-import releaser from "../../scripts/releaser";
+import {
+  deployDeterministic,
+  deploySuperGoodDollar,
+  verifyProductionSigner
+} from "./helpers";
+import releaser from "../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> => {
@@ -36,85 +37,99 @@ const printDeploy = async (
 };
 
 export const createDAO = async () => {
-  const fusedao = dao[network.name.split("-")[0]];
-  const protocolSettings = ProtocolSettings["production"];
-  let release: { [key: string]: any } = {};
+  let protocolSettings = defaultsDeep(
+    {},
+    ProtocolSettings[network.name],
+    ProtocolSettings["default"]
+  );
+
+  let release: { [key: string]: any } = dao[network.name];
+  const isProduction = network.name.includes("production");
 
-  let [root, ...signers] = await ethers.getSigners();
-  //generic call permissions
-  let schemeMock = root;
-  const isMainnet = network.name.includes("main");
+  let [root] = await ethers.getSigners();
+  const daoOwner = root.address;
+  if (isProduction) verifyProductionSigner(root);
 
   console.log("got signers:", {
     network,
+    daoOwner,
     root: root.address,
-    schemeMock: schemeMock.address,
     balance: await ethers.provider
       .getBalance(root.address)
-      .then(_ => _.toString())
+      .then(_ => _.toString()),
+    release
   });
 
-  if (network.name.includes("production")) {
-    const txCount = await root.getTransactionCount();
-    if (txCount !== 7) {
-      console.error(
-        "nonce doesnt match expected 7, to have same contract address",
-        { txCount }
-      );
-      return;
-    }
-  }
-
   const DAOCreatorFactory = new ethers.ContractFactory(
     DAOCreatorABI.abi,
     DAOCreatorABI.bytecode,
     root
   );
 
-  const IdentityFactory = new ethers.ContractFactory(
-    IdentityABI.abi,
-    IdentityABI.bytecode,
-    root
-  );
   const FeeFormulaFactory = new ethers.ContractFactory(
     FeeFormulaABI.abi,
     FeeFormulaABI.bytecode,
     root
   );
-  const AddFoundersFactory = new ethers.ContractFactory(
-    AddFoundersABI.abi,
-    AddFoundersABI.bytecode,
-    root
-  );
-
-  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: "Identity",
-      factory: IdentityFactory
+      name: "IdentityV2",
+      salt: "Identity",
+      isUpgradeable: true
     },
-    [root.address]
+    [root.address, ethers.constants.AddressZero]
   ).then(printDeploy)) as Contract;
 
-  // const Identity = await ethers.getContractAt(
-  //   IdentityABI.abi,
-  //   release.Identity
-  // );
-
-  const daoCreator = await DAOCreatorFactory.deploy(AddFounders.address);
+  const daoCreator = await DAOCreatorFactory.deploy();
 
   const FeeFormula = (await deployDeterministic(
     { name: "FeeFormula", factory: FeeFormulaFactory },
     [0]
   ).then(printDeploy)) as Contract;
 
+  let GoodDollar;
+  if (protocolSettings.superfluidHost) {
+    GoodDollar = await deploySuperGoodDollar(protocolSettings.superfluidHost, [
+      isProduction ? "GoodDollar" : "GoodDollar Dev",
+      "G$",
+      0,
+      FeeFormula.address,
+      Identity.address,
+      ethers.constants.AddressZero,
+      daoCreator.address
+    ]);
+  } else {
+    GoodDollar = (await deployDeterministic(
+      {
+        name: "GoodDollar",
+        isUpgradeable: true,
+        initializer:
+          "initialize(string, string, uint256, address, address, address,address)"
+      },
+      [
+        isProduction ? "GoodDollar" : "GoodDollar Dev",
+        "G$",
+        0,
+        FeeFormula.address,
+        Identity.address,
+        ethers.constants.AddressZero,
+        daoCreator.address
+      ]
+    ).then(printDeploy)) as Contract;
+  }
+
   const GReputation = (await deployDeterministic(
     {
       name: "GReputation",
@@ -129,22 +144,12 @@ 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
-    .forgeOrg(
-      "GoodDollar",
-      "G$",
-      0,
-      FeeFormula.address,
-      Identity.address,
-      GReputation.address,
-      [],
-      0,
-      []
-    )
+    .forgeOrg(GoodDollar.address, GReputation.address, [], 0, [])
     .then(printDeploy);
   console.log("forgeOrg done ");
   const Avatar = new ethers.Contract(
@@ -156,20 +161,9 @@ 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 = [process.env.DAO_OWNER, Identity.address];
+  let schemes = [daoOwner, Identity.address];
 
   const gd = await Avatar.nativeToken();
 
@@ -191,31 +185,40 @@ export const createDAO = async () => {
     { name: "NameService", isUpgradeable: true },
     [
       controller,
-      ["CONTROLLER", "AVATAR", "IDENTITY", "GOODDOLLAR"].map(_ =>
+      ["CONTROLLER", "AVATAR", "IDENTITY", "GOODDOLLAR", "REPUTATION"].map(_ =>
         ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))
       ),
-      [controller, Avatar.address, Identity.address, gd]
+      [controller, Avatar.address, Identity.address, gd, GReputation.address]
     ]
   );
 
+  console.log("set GRep nameservice..");
   await (await GReputation.updateDAO(NameService.address)).wait();
-  console.log("GRep nameservice:");
+  console.log("set Identity nameservice..");
+
+  await Identity.initDAO(NameService.address).then(printDeploy);
+
   //verifications
   const Controller = await ethers.getContractAt("Controller", controller);
-  const GoodDollar = await ethers.getContractAt("IGoodDollar", gd);
 
-  await GoodDollar.renounceMinter().then(printDeploy);
-  await Identity.transferOwnership(process.env.DAO_OWNER).then(printDeploy);
+  if (isProduction) {
+    console.log("renouncing minting rights on production env");
+    await GoodDollar.renounceMinter().then(printDeploy);
+  }
 
   const daoOwnerDaoPermissions = await Controller.getSchemePermissions(
-    process.env.DAO_OWNER,
+    daoOwner,
     Avatar.address
   );
 
   const deployerIsNotGDMinter =
     (await GoodDollar.isMinter(root.address)) === false;
+
   const avatarIsGDMinter = await GoodDollar.isMinter(Avatar.address);
 
+  const deployerIsNotGDPauser =
+    (await GoodDollar.isPauser(root.address)) === false;
+
   const deployerIsNotRepMinter =
     (await GReputation.hasRole(GReputation.MINTER_ROLE(), root.address)) ===
     false;
@@ -223,8 +226,16 @@ export const createDAO = async () => {
     GReputation.MINTER_ROLE(),
     Avatar.address
   );
-  const daoOwnerIsIdentityOwner =
-    process.env.DAO_OWNER === (await Identity.owner());
+
+  const deployerIsIdentityOwner = await Identity.hasRole(
+    ethers.constants.HashZero,
+    root.address
+  );
+
+  const avatarIsIdentityOwner = await Identity.hasRole(
+    ethers.constants.HashZero,
+    Avatar.address
+  );
 
   //try to modify DAO -> should not succeed
   await (await GReputation.updateDAO(ethers.constants.AddressZero)).wait();
@@ -232,29 +243,48 @@ export const createDAO = async () => {
   const grepHasDAOSet =
     (await GReputation.nameService()) === NameService.address;
 
+  const factoryIsNotGoodOwner =
+    (await GReputation.hasRole(
+      ethers.constants.HashZero,
+      proxyFactory.address
+    )) === false;
+
+  const factoryIsNotGDMinter =
+    (await GoodDollar.isMinter(proxyFactory.address)) === false;
+
+  const factoryIsNotGDPauser =
+    (await GoodDollar.isPauser(root.address)) === false;
+
   console.log({
     daoOwnerDaoPermissions,
     deployerIsNotGDMinter,
     deployerIsNotRepMinter,
+    deployerIsNotGDPauser,
+    factoryIsNotGoodOwner,
+    factoryIsNotGDMinter,
+    factoryIsNotGDPauser,
     avatarIsRepMinter,
-    daoOwnerIsIdentityOwner,
+    deployerIsIdentityOwner,
+    avatarIsIdentityOwner,
     avatarIsGDMinter,
     grepHasDAOSet
   });
 
   release = {
-    ProxyFactory: "0x99C22e78A579e2176311c736C4c9F0b0D5A47806",
+    // ProxyFactory: "0x99C22e78A579e2176311c736C4c9F0b0D5A47806",
     GoodDollar: gd,
     Avatar: Avatar.address,
     Controller: controller,
     Identity: Identity.address,
     NameService: NameService.address,
-    GReputation: GReputation.address
+    GReputation: GReputation.address,
+    FeeFormula: FeeFormula.address,
+    DAOCreator: daoCreator.address
   };
   await releaser(release, network.name, "deployment", false);
 };
 
-export const main = async (networkName = name) => {
-  await createDAO().catch(console.log);
+export const main = async () => {
+  await createDAO();
 };
 main();

package/scripts/multichain-deploy/2_helpers-deploy.ts

@@ -0,0 +1,151 @@
+/***
+ * Deploy helper contracts
+ * AdminWallet, Faucet, Invites
+ */
+import { network, ethers, upgrades, run } from "hardhat";
+import { Contract } from "ethers";
+import { defaultsDeep } from "lodash";
+import { deployDeterministic, verifyProductionSigner } from "./helpers";
+import releaser from "../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> => {
+  if (c instanceof Contract) {
+    await c.deployed();
+    console.log("deployed to: ", c.address);
+  }
+  if (c.wait) {
+    await c.wait();
+    console.log("tx done:", c.hash);
+  }
+  return c;
+};
+
+export const deployHelpers = async () => {
+  let protocolSettings = defaultsDeep(
+    {},
+    ProtocolSettings[network.name],
+    ProtocolSettings["default"]
+  );
+
+  let release: { [key: string]: any } = dao[network.name];
+
+  let [root] = await ethers.getSigners();
+  const isProduction = network.name.includes("production");
+
+  if (isProduction) verifyProductionSigner(root);
+
+  //generic call permissions
+  let schemeMock = root;
+
+  console.log("got signers:", {
+    network,
+    root: root.address,
+    schemeMock: schemeMock.address,
+    balance: await ethers.provider
+      .getBalance(root.address)
+      .then(_ => _.toString())
+  });
+
+  const walletAdmins = [];
+  for (let i = 0; i < protocolSettings.walletAdminsCount; i++) {
+    const wallet = ethers.Wallet.fromMnemonic(
+      process.env.ADMIN_WALLET_MNEMONIC,
+      `m/44'/60'/0'/0/${i}`
+    );
+    walletAdmins.push(wallet.address);
+  }
+
+  console.log("deploying adminwallet", { walletAdmins });
+  const AdminWallet = (await deployDeterministic(
+    {
+      //   address payable[] memory _admins,
+      // address _owner,
+      // IIdentityV2 _identity
+      name: "AdminWallet",
+      salt: "AdminWallet",
+      isUpgradeable: true
+    },
+    [walletAdmins, release.NameService, root.address, protocolSettings.gasPrice]
+  ).then(printDeploy)) as Contract;
+
+  console.log("giving AdminWallet identity_admin permissions");
+  const gd = await ethers.getContractAt("IGoodDollar", release.GoodDollar);
+
+  const decimals = await gd.decimals();
+
+  const identity = await ethers.getContractAt("IdentityV2", release.Identity);
+  await identity.grantRole(
+    ethers.utils.keccak256(ethers.utils.toUtf8Bytes("identity_admin")),
+    AdminWallet.address
+  );
+
+  const Faucet = await deployDeterministic(
+    { name: "Faucet", salt: "Faucet", isUpgradeable: true },
+    [
+      release.NameService,
+      protocolSettings.gasPrice,
+      AdminWallet.address,
+      root.address
+    ]
+  );
+
+  const Invites = await deployDeterministic(
+    { name: "InvitesV2", salt: "InvitesV2", isUpgradeable: true },
+    [
+      release.NameService,
+      ethers.BigNumber.from(100).mul(ethers.BigNumber.from("10").pow(decimals)),
+      root.address
+    ]
+  );
+
+  const adminWalletOwner = await AdminWallet.hasRole(
+    ethers.constants.HashZero,
+    root.address
+  );
+  const faucetOwner = await Faucet.hasRole(
+    ethers.constants.HashZero,
+    root.address
+  );
+
+  console.log("topping adminwallet and faucet with 1 native token");
+  await root.sendTransaction({
+    to: AdminWallet.address,
+    value: ethers.constants.WeiPerEther
+  });
+  await root.sendTransaction({
+    to: Faucet.address,
+    value: ethers.constants.WeiPerEther
+  });
+
+  if (!network.name.includes("production")) {
+    console.log("minting G$s to invites on dev envs");
+    await gd.mint(
+      Invites.address,
+      ethers.BigNumber.from(1e6).mul(ethers.BigNumber.from("10").pow(decimals))
+    ); //1million GD
+  }
+
+  console.log({
+    adminWalletOwner,
+    faucetOwner
+  });
+
+  release = {
+    AdminWallet: AdminWallet.address,
+    Faucet: Faucet.address,
+    Invites: Invites.address
+  };
+  await releaser(release, network.name, "deployment", false);
+};
+
+export const main = async (networkName = name) => {
+  await deployHelpers();
+};
+main();