@gooddollar/goodprotocol 2.0.32 → 2.0.34-beta.0

package/scripts/fv.ts

@@ -13,6 +13,7 @@ const saveImage = async (id, idx) => {
   }).then(_ => _.json());
   console.log({ age });
   const i1 = await fetch("http://localhost:9090/enrollment-3d/" + id).then(_ => _.json());
+  console.log(i1);
   fs.writeFileSync("fvimages/" + id + "_" + idx + ".jpg", i1.auditTrailBase64, {
     encoding: "base64"
   });
@@ -239,9 +240,26 @@ const exportScans = async ids => {
   });
   await Promise.all(exports);
 };
+
+const deleteIdentifier = async (id, walletAddress) => {
+  const res = await fetch("https://goodserver.gooddollar.org/admin/verify/face/delete", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      password: process.env.ADMIN_PASSWORD,
+      enrollmentIdentifier: id,
+      walletAddress
+    })
+  })
+    .then(_ => _.json())
+    .catch(_ => _);
+  console.log(res);
+};
 // checkIndexedOrDelete();
 // fixInvalidIndexed();
 // console.log(process.env.ADMIN_PASSWORD);
 // deleteIdentifiers(process.env.ADMIN_PASSWORD);
 // main();
-saveImages(["", "", ""]);
+// saveImages(["", "", ""]);
+// saveImage("0x62c60cefbc22d0109d63ab3b517d0631a58aedc5", 0);
+deleteIdentifier("0x62c60cefbc22d0109d63ab3b517d0631a58aedc5", "0x2254690603d951f46b480df000f254e9a7b77246");

package/scripts/multichain-deploy/0_proxyFactory-deploy.ts

@@ -1,9 +1,10 @@
-import { network, ethers, upgrades, run } from "hardhat";
-import { Contract } from "ethers";
+import hre from "hardhat";
+import { network, ethers } from "hardhat";
 
-import { verifyProductionSigner } from "./helpers";
+import { verifyContract, verifyOnEtherscan, verifyProductionSigner } from "./helpers";
 import releaser from "../../scripts/releaser";
 import dao from "../../releases/deployment.json";
+import { keccak256, parseUnits, toUtf8Bytes } from "ethers/lib/utils";
 
 const { name } = network;
 const celoProxyByteCode =
@@ -15,7 +16,7 @@ export const deployUniversalProxyFactory = async () => {
   const deployTx = {
     nonce: 0,
     gasPrice: 50e9,
-    gasLimit: 891002,
+    gasLimit: 2891002,
     data: celoProxyByteCode
   };
 
@@ -98,8 +99,30 @@ export const deployProxy = async (defaultAdmin = null) => {
   await releaser(release, network.name, "deployment", false);
 };
 
+const deployProxyMethod2 = async (defaultAdmin = null) => {
+  let [signer] = await ethers.getSigners();
+  console.log("deploying proxyfactory with signer", {
+    address: signer.address,
+    balance: await ethers.provider.getBalance(signer.address).then(_ => _.toString())
+  });
+  const artifact = await hre.artifacts.readArtifact("ProxyFactory1967");
+  const result = await hre.deployments.deterministic("ProxyFactory", {
+    skipIfAlreadyDeployed: true,
+    salt: keccak256(toUtf8Bytes("ProxyFactory")),
+    contract: artifact,
+    from: signer.address
+  });
+  const deployed = await result.deploy();
+  console.log(result, deployed);
+  const release = {
+    ProxyFactory: deployed.address
+  };
+  await releaser(release, network.name, "deployment", false);
+  await verifyContract(deployed.address, artifact.sourceName + ":" + artifact.contractName);
+};
 export const main = async (networkName = name) => {
-  await deployProxy();
+  // await deployProxy();
+  await deployProxyMethod2();
 };
 
 if (process.argv[1].includes("proxyFactory-deploy")) {

package/scripts/multichain-deploy/1_basicdao-deploy.ts

@@ -12,12 +12,18 @@ import DAOCreatorABI from "@gooddollar/goodcontracts/build/contracts/DaoCreatorG
 // import IdentityABI from "@gooddollar/goodcontracts/build/contracts/Identity.json";
 import FeeFormulaABI from "@gooddollar/goodcontracts/build/contracts/FeeFormula.json";
 
-import { deployDeterministic, deploySuperGoodDollar, verifyProductionSigner } from "./helpers";
+import {
+  deployDeterministic,
+  deploySuperGoodDollar,
+  verifyProductionSigner,
+  verifyContract,
+  verifyOnEtherscan
+} from "./helpers";
 import releaser from "../releaser";
 import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
 import { TransactionResponse } from "@ethersproject/providers";
-
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 const printDeploy = async (c: Contract | TransactionResponse): Promise<Contract | TransactionResponse> => {
   if (c instanceof Contract) {
     await c.deployed();
@@ -33,10 +39,11 @@ const printDeploy = async (c: Contract | TransactionResponse): Promise<Contract
 export const createDAO = async () => {
   let protocolSettings = defaultsDeep({}, ProtocolSettings[network.name], ProtocolSettings["default"]);
 
-  let release: { [key: string]: any } = dao[network.name];
+  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);
 
@@ -52,16 +59,13 @@ export const createDAO = async () => {
 
   const FeeFormulaFactory = new ethers.ContractFactory(FeeFormulaABI.abi, FeeFormulaABI.bytecode, root);
 
-  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 });
+  console.log("deploying identity");
   let Identity;
-  if (release.Identity) Identity = await ethers.getContractAt("IdentityV2", release.Identity);
+  if (release.Identity) Identity = await ethers.getContractAt("IdentityV3", release.Identity);
   else
     Identity = (await deployDeterministic(
       {
-        name: "IdentityV2",
+        name: "IdentityV3",
         salt: "Identity",
         isUpgradeable: true
       },
@@ -70,7 +74,17 @@ export const createDAO = async () => {
 
   let daoCreator;
   if (release.DAOCreator) daoCreator = await DAOCreatorFactory.attach(release.DAOCreator);
-  else daoCreator = (await DAOCreatorFactory.deploy().then(printDeploy)) as Contract;
+  else {
+    daoCreator = await deployDeterministic(
+      {
+        name: "DAOCreator",
+        factory: DAOCreatorFactory,
+        isUpgradeable: false
+      },
+      []
+    );
+    // daoCreator = (await DAOCreatorFactory.deploy().then(printDeploy)) as Contract;
+  }
 
   let FeeFormula;
   if (release.FeeFormula) FeeFormula = await FeeFormulaFactory.attach(release.FeeFormula);
@@ -80,8 +94,7 @@ export const createDAO = async () => {
     )) as Contract;
 
   let GoodDollar;
-  let { superfluidHost, superfluidInflowNFTLogic, superfluidOutflowNFTLogic } =
-    protocolSettings;
+  let { superfluidHost, superfluidInflowNFTLogic, superfluidOutflowNFTLogic } = protocolSettings;
   if (protocolSettings.superfluidHost) {
     GoodDollar = await deploySuperGoodDollar(
       {
@@ -118,66 +131,58 @@ export const createDAO = async () => {
     ).then(printDeploy)) as Contract;
   }
 
-  const GReputation = (await deployDeterministic(
-    {
-      name: "GReputation",
-      isUpgradeable: true,
-      initializer: "initialize(address, string, bytes32, uint256)"
-    },
-    [
-      ethers.constants.AddressZero,
-      "fuse",
-      protocolSettings.governance.gdaoAirdrop, //should fail on real deploy if not set
-      protocolSettings.governance.gdaoTotalSupply //should fail on real deploy if not set
-    ]
-  ).then(printDeploy)) as Contract;
-
   // console.log("setting identity auth period");
   // await Identity.setAuthenticationPeriod(365).then(printDeploy);
 
-  console.log("creating dao");
-  await daoCreator.forgeOrg(GoodDollar.address, GReputation.address, [], 0, []).then(printDeploy);
-  console.log("forgeOrg done ");
-  const Avatar = new ethers.Contract(
-    await daoCreator.avatar(),
+  const avatar = await daoCreator.avatar();
+  let Avatar = new ethers.Contract(
+    avatar,
     ["function owner() view returns (address)", "function nativeToken() view returns (address)"],
     root
   );
-
-  console.log("Done deploying DAO, setting schemes permissions");
-
-  let schemes = [daoOwner, Identity.address];
+  if (avatar === ethers.constants.AddressZero) {
+    console.log("creating dao");
+    await daoCreator.forgeOrg(GoodDollar.address, ethers.constants.AddressZero, [], 0, []).then(printDeploy);
+    console.log("forgeOrg done ");
+    console.log("Done deploying DAO, setting schemes permissions");
+
+    Avatar = new ethers.Contract(
+      await daoCreator.avatar(),
+      ["function owner() view returns (address)", "function nativeToken() view returns (address)"],
+      root
+    );
+    let schemes = [daoOwner, Identity.address];
+
+    console.log("setting schemes", schemes);
+
+    await daoCreator
+      .setSchemes(
+        Avatar.address,
+        schemes,
+        schemes.map(_ => ethers.constants.HashZero),
+        ["0x0000001f", "0x00000001"],
+        ""
+      )
+      .then(printDeploy);
+  } else {
+    console.log("dao already exists, avatar is", avatar);
+  }
 
   const gd = await Avatar.nativeToken();
 
   const controller = await Avatar.owner();
 
-  console.log("setting schemes", schemes);
-
-  await daoCreator
-    .setSchemes(
-      Avatar.address,
-      schemes,
-      schemes.map(_ => ethers.constants.HashZero),
-      ["0x0000001f", "0x00000001"],
-      ""
-    )
-    .then(printDeploy);
-
   const NameService = await deployDeterministic({ name: "NameService", isUpgradeable: true }, [
     controller,
-    ["CONTROLLER", "AVATAR", "IDENTITY", "GOODDOLLAR", "REPUTATION"].map(_ =>
-      ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))
-    ),
-    [controller, Avatar.address, Identity.address, gd, GReputation.address]
+    ["CONTROLLER", "AVATAR", "IDENTITY", "GOODDOLLAR"].map(_ => ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))),
+    [controller, Avatar.address, Identity.address, gd]
   ]);
 
-  console.log("set GRep nameservice..");
-  await (await GReputation.updateDAO(NameService.address)).wait();
   console.log("set Identity nameservice..");
 
-  await Identity.initDAO(NameService.address).then(printDeploy);
-
+  if ((await Identity.nameService()) == ethers.constants.AddressZero) {
+    await Identity.initDAO(NameService.address).then(printDeploy);
+  }
   //verifications
   const Controller = await ethers.getContractAt("Controller", controller);
 
@@ -194,37 +199,24 @@ export const createDAO = async () => {
 
   const deployerIsNotGDPauser = (await GoodDollar.isPauser(root.address)) === false;
 
-  const deployerIsNotRepMinter = (await GReputation.hasRole(GReputation.MINTER_ROLE(), root.address)) === false;
-  const avatarIsRepMinter = await GReputation.hasRole(GReputation.MINTER_ROLE(), Avatar.address);
-
   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();
-
-  const grepHasDAOSet = (await GReputation.nameService()) === NameService.address;
-
-  const factoryIsNotGoodOwner = (await GReputation.hasRole(ethers.constants.HashZero, proxyFactory.address)) === false;
+  const avatarIsIdentityOwner = (await Identity.hasRole(ethers.constants.HashZero, Avatar.address)) === true;
 
-  const factoryIsNotGDMinter = (await GoodDollar.isMinter(proxyFactory.address)) === false;
+  const factoryIsNotGDMinter = (await GoodDollar.isMinter(release.ProxyFactory)) === false;
 
   const factoryIsNotGDPauser = (await GoodDollar.isPauser(root.address)) === false;
-
+  const identityNameService = (await Identity.nameService()) === NameService.address;
   console.log({
     daoOwnerDaoPermissions,
     deployerIsNotGDMinter,
-    deployerIsNotRepMinter,
     deployerIsNotGDPauser,
-    factoryIsNotGoodOwner,
     factoryIsNotGDMinter,
     factoryIsNotGDPauser,
-    avatarIsRepMinter,
     deployerIsIdentityOwner,
     avatarIsIdentityOwner,
     avatarIsGDMinter,
-    grepHasDAOSet
+    identityNameService
   });
 
   release = {
@@ -234,11 +226,57 @@ export const createDAO = async () => {
     Controller: controller,
     Identity: Identity.address,
     NameService: NameService.address,
-    GReputation: GReputation.address,
     FeeFormula: FeeFormula.address,
     DAOCreator: daoCreator.address
   };
   await releaser(release, network.name, "deployment", false);
+
+  await verifyOnEtherscan(
+    network.config.chainId,
+    "scripts/multichain-deploy/flattened/Avatar.sol",
+    "Avatar",
+    Avatar.address,
+    "v0.5.16+commit.9c3226ce",
+    {
+      types: ["string", "address", "address"],
+      values: ["GoodDollar", GoodDollar.address, ethers.constants.AddressZero]
+    }
+  );
+  await verifyOnEtherscan(
+    network.config.chainId,
+    "scripts/multichain-deploy/flattened/Controller.sol",
+    "Controller",
+    Controller.address,
+    "v0.5.16+commit.9c3226ce",
+    {
+      types: ["address"],
+      values: [Avatar.address]
+    }
+  );
+  await verifyOnEtherscan(
+    network.config.chainId,
+    "scripts/multichain-deploy/flattened/FeeFormula.sol",
+    "FeeFormula",
+    FeeFormula.address,
+    "v0.5.16+commit.9c3226ce",
+    {
+      types: ["uint256"],
+      values: [0]
+    }
+  );
+
+  let impl = await getImplementationAddress(ethers.provider, Identity.address);
+  await verifyContract(impl, "contracts/identity/IdentityV3.sol:IdentityV3", network.name);
+  impl = await getImplementationAddress(ethers.provider, NameService.address);
+  await verifyContract(impl, "contracts/utils/NameService.sol:NameService", network.name);
+  if (protocolSettings.superfluidHost) {
+    impl = await getImplementationAddress(ethers.provider, GoodDollar.address);
+    await verifyContract(GoodDollar.address, "contracts/token/superfluid/UUPSProxy.sol:UUPSProxy", network.name);
+    await verifyContract(impl, "contracts/token/superfluid/SuperGoodDollar.sol:SuperGoodDollar", network.name);
+  } else {
+    impl = await getImplementationAddress(ethers.provider, GoodDollar.address);
+    await verifyContract(impl, "contracts/token/GoodDollar.sol:GoodDollar", network.name);
+  }
 };
 
 export const main = async () => {

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

@@ -11,6 +11,7 @@ import releaser from "../releaser";
 import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
 import { TransactionResponse } from "@ethersproject/providers";
+import { AdminWallet, Faucet } from "../../types";
 
 const { name } = network;
 
@@ -64,24 +65,28 @@ export const deployHelpers = async () => {
       isUpgradeable: true
     },
     [walletAdmins, release.NameService, root.address, protocolSettings.gasPrice]
-  ).then(printDeploy)) as Contract;
+  ).then(printDeploy)) as AdminWallet;
+
+  await AdminWallet.setDefaults(1e6, 9e6, 3, protocolSettings.gasPrice);
   // const AdminWallet = await ethers.getContractAt("AdminWallet", release.AdminWallet);
 
   const gd = await ethers.getContractAt("IGoodDollar", release.GoodDollar);
 
   const decimals = await gd.decimals();
 
-  const Faucet = await deployDeterministic({ name: "Faucet", salt: "Faucet", isUpgradeable: true }, [
+  const Faucet = (await deployDeterministic({ name: "Faucet", salt: "Faucet", isUpgradeable: true }, [
     release.NameService,
     protocolSettings.gasPrice,
     AdminWallet.address,
     root.address
-  ]);
+  ])) as Faucet;
+
+  await Faucet.setGasTopping(1.5e6);
   // const Faucet = await ethers.getContractAt("Faucet", release.Faucet);
 
   const Invites = await deployDeterministic({ name: "InvitesV2", salt: "InvitesV2", isUpgradeable: true }, [
     release.NameService,
-    ethers.BigNumber.from(100).mul(ethers.BigNumber.from("10").pow(decimals)),
+    ethers.utils.parseUnits("100", decimals),
     root.address
   ]);
 
@@ -124,7 +129,7 @@ export const deployHelpers = async () => {
 
   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
+    await gd.mint(Invites.address, ethers.utils.parseUnits("1000000", decimals)); //1million GD
   }
 
   console.log({
@@ -134,11 +139,11 @@ export const deployHelpers = async () => {
   });
 
   let impl = await getImplementationAddress(ethers.provider, AdminWallet.address);
-  await verifyContract(impl, "AdminWallet", network.name);
+  await verifyContract(impl, "contracts/utils/AdminWallet.sol:AdminWallet", network.name);
   impl = await getImplementationAddress(ethers.provider, Faucet.address);
-  await verifyContract(impl, "Faucet", network.name);
+  await verifyContract(impl, "contracts/fuseFaucet/Faucet.sol:Faucet", network.name);
   impl = await getImplementationAddress(ethers.provider, Invites.address);
-  await verifyContract(impl, "InvitesV2", network.name);
+  await verifyContract(impl, "contracts/invite/InvitesV2.sol:InvitesV2", network.name);
 };
 
 export const main = async () => {

package/scripts/multichain-deploy/4_ubi-deploy.ts

@@ -56,36 +56,37 @@ export const deployHelpers = async () => {
   console.log("deploying ubi pool");
   const UBIScheme = (await deployDeterministic(
     {
-      name: "UBIScheme",
+      name: "UBISchemeV2",
+      factory: await ethers.getContractFactory("UBISchemeV2"),
       isUpgradeable: true
     },
-    [release.NameService, ethers.constants.AddressZero, protocolSettings.ubi.maxInactiveDays]
+    [release.NameService]
   ).then(printDeploy)) as Contract;
 
-  console.log("deploying claimers distribution");
-
-  const ClaimersDistribution = (await deployDeterministic({ name: "ClaimersDistribution", isUpgradeable: true }, [
-    release.NameService
-  ]).then(printDeploy)) as Contract;
+  const torelease = {
+    UBIScheme: UBIScheme.address
+  };
+  release = {
+    ...release,
+    ...torelease
+  };
+  await releaser(torelease, network.name, "deployment", false);
 
   console.log("setting nameservice addresses via guardian");
   const proposalContracts = [
-    release.NameService //nameservice add MinterWrapper
+    release.NameService //nameservice
   ];
 
   const proposalEthValues = proposalContracts.map(_ => 0);
 
   const proposalFunctionSignatures = [
-    "setAddresses(bytes32[],address[])" //add ubischeme and claimersdistribution in nameservice
+    "setAddresses(bytes32[],address[])" //add ubischeme
   ];
 
   const proposalFunctionInputs = [
     ethers.utils.defaultAbiCoder.encode(
       ["bytes32[]", "address[]"],
-      [
-        [keccak256(toUtf8Bytes("UBISCHEME")), keccak256(toUtf8Bytes("GDAO_CLAIMERS"))],
-        [UBIScheme.address, ClaimersDistribution.address]
-      ]
+      [[keccak256(toUtf8Bytes("UBISCHEME"))], [UBIScheme.address]]
     )
   ];
 
@@ -96,12 +97,6 @@ export const deployHelpers = async () => {
     await gd.mint(UBIScheme.address, ethers.BigNumber.from(1e6).mul(ethers.BigNumber.from("10").pow(decimals))); //1million GD
   }
 
-  let impl = await getImplementationAddress(ethers.provider, UBIScheme.address);
-  await verifyContract(impl, "UBIScheme", network.name);
-
-  impl = await getImplementationAddress(ethers.provider, ClaimersDistribution.address);
-  await verifyContract(impl, "ClaimersDistribution", network.name);
-
   try {
     if (viaGuardians) {
       await executeViaSafe(
@@ -123,6 +118,9 @@ export const deployHelpers = async () => {
   } catch (e) {
     console.error("proposal execution failed...", e.message);
   }
+
+  let impl = await getImplementationAddress(ethers.provider, UBIScheme.address);
+  await verifyContract(impl, "contracts/ubi/UBISchemeV2.sol:UBISchemeV2", network.name);
 };
 
 export const main = async (networkName = name) => {

package/scripts/multichain-deploy/5_gov-deploy.ts

@@ -5,11 +5,13 @@
 import { network, ethers, upgrades, run } from "hardhat";
 import { Contract } from "ethers";
 import { defaultsDeep } from "lodash";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 import {
   deployDeterministic,
   executeViaGuardian,
   executeViaSafe,
-  verifyProductionSigner
+  verifyProductionSigner,
+  verifyContract
 } from "./helpers";
 import releaser from "../releaser";
 import ProtocolSettings from "../../releases/deploy-settings.json";
@@ -19,9 +21,7 @@ import { keccak256, toUtf8Bytes } from "ethers/lib/utils";
 
 const { name } = network;
 
-const printDeploy = async (
-  c: Contract | TransactionResponse
-): Promise<Contract | TransactionResponse> => {
+const printDeploy = async (c: Contract | TransactionResponse): Promise<Contract | TransactionResponse> => {
   if (c instanceof Contract) {
     await c.deployed();
     console.log("deployed to: ", c.address);
@@ -34,11 +34,7 @@ const printDeploy = async (
 };
 
 export const deployGov = async () => {
-  let protocolSettings = defaultsDeep(
-    {},
-    ProtocolSettings[network.name],
-    ProtocolSettings["default"]
-  );
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[network.name], ProtocolSettings["default"]);
   let release: { [key: string]: any } = dao[network.name];
 
   let [root] = await ethers.getSigners();
@@ -52,11 +48,23 @@ export const deployGov = async () => {
   console.log("got signers:", {
     network,
     root: root.address,
-    balance: await ethers.provider
-      .getBalance(root.address)
-      .then(_ => _.toString())
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
   });
 
+  const GReputation = (await deployDeterministic(
+    {
+      name: "GReputation",
+      isUpgradeable: true,
+      initializer: "initialize(address, string, bytes32, uint256)"
+    },
+    [
+      release.NameService,
+      "fuse",
+      protocolSettings.governance.gdaoAirdrop, //should fail on real deploy if not set
+      protocolSettings.governance.gdaoTotalSupply //should fail on real deploy if not set
+    ]
+  ).then(printDeploy)) as Contract;
+
   console.log("deploying voting machine");
 
   const VotingMachine = (await deployDeterministic(
@@ -72,8 +80,16 @@ export const deployGov = async () => {
     ]
   ).then(printDeploy)) as Contract;
 
+  console.log("deploying claimers distribution");
+
+  const ClaimersDistribution = (await deployDeterministic({ name: "ClaimersDistribution", isUpgradeable: true }, [
+    release.NameService
+  ]).then(printDeploy)) as Contract;
+
   const torelease = {
-    CompoundVotingMachine: VotingMachine.address
+    CompoundVotingMachine: VotingMachine.address,
+    GReputation: GReputation.address,
+    ClaimersDistribution: ClaimersDistribution.address
   };
   release = {
     ...release,
@@ -81,29 +97,51 @@ export const deployGov = async () => {
   };
   await releaser(torelease, network.name, "deployment", false);
 
+  const deployerIsNotRepMinter = (await GReputation.hasRole(GReputation.MINTER_ROLE(), root.address)) === false;
+  const avatarIsRepMinter = await GReputation.hasRole(GReputation.MINTER_ROLE(), release.Avatar);
+  const grepHasDAOSet = (await GReputation.nameService()) === release.NameService;
+  const factoryIsNotGoodOwner = (await GReputation.hasRole(ethers.constants.HashZero, release.ProxyFactory)) === false;
+  console.log("verify GReputation permissions", {
+    deployerIsNotRepMinter,
+    avatarIsRepMinter,
+    grepHasDAOSet,
+    factoryIsNotGoodOwner
+  });
+
   console.log("adding genericcall permissions to voting contract.");
   const proposalContracts = [
+    release.NameService,
     release.Controller //nameservice add MinterWrapper
   ];
 
   const proposalEthValues = proposalContracts.map(_ => 0);
 
   const proposalFunctionSignatures = [
+    "setAddresses(bytes32[],address[])", //add reputation
     "registerScheme(address,bytes32,bytes4,address)" //make sure compoundvotingmachine has generic call so it can control the DAO
   ];
 
   const proposalFunctionInputs = [
     ethers.utils.defaultAbiCoder.encode(
-      ["address", "bytes32", "bytes4", "address"],
+      ["bytes32[]", "address[]"],
       [
-        release.CompoundVotingMachine,
-        ethers.constants.HashZero,
-        "0x000000f1",
-        release.Avatar
+        [keccak256(toUtf8Bytes("REPUTATION")), keccak256(toUtf8Bytes("GDAO_CLAIMERS"))],
+        [GReputation.address, ClaimersDistribution.address]
       ]
+    ),
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "bytes32", "bytes4", "address"],
+      [release.CompoundVotingMachine, ethers.constants.HashZero, "0x000000f1", release.Avatar]
     )
   ];
 
+  let impl = await getImplementationAddress(ethers.provider, ClaimersDistribution.address);
+  await verifyContract(impl, "ClaimersDistribution", network.name);
+  impl = await getImplementationAddress(ethers.provider, VotingMachine.address);
+  await verifyContract(impl, "CompoundVotingMachine", network.name);
+  impl = await getImplementationAddress(ethers.provider, GReputation.address);
+  await verifyContract(impl, "GReputation", network.name);
+
   try {
     if (viaGuardians) {
       await executeViaSafe(
@@ -126,15 +164,9 @@ export const deployGov = async () => {
     console.error("proposal execution failed...", e.message);
   }
 
-  const Controller = await ethers.getContractAt(
-    "Controller",
-    release.Controller
-  );
+  const Controller = await ethers.getContractAt("Controller", release.Controller);
 
-  const votingMachineDaoPermissions = await Controller.getSchemePermissions(
-    daoOwner,
-    release.Avatar
-  );
+  const votingMachineDaoPermissions = await Controller.getSchemePermissions(daoOwner, release.Avatar);
 
   console.log({
     votingMachineDaoPermissions