Monorepo support

.gitignore

@@ -25,4 +25,7 @@ tags
 .log/
 yarn-error.log
 venv/
-contracts/hardhat-dependency-compiler
+contracts/hardhat-dependency-compiler
+types
+.turbo
+bytecodes

contracts/utils/PermissionRegistry.sol

@@ -237,8 +237,7 @@ contract PermissionRegistry is OwnableUpgradeable {
             uint256 currentBalance = IERC20(erc20Limits[from][i].token).balanceOf(from);
             if (currentBalance < erc20Limits[from][i].initialValueOnBlock) {
                 require(
-                    erc20Limits[from][i].initialValueOnBlock.sub(currentBalance) <=
-                        erc20Limits[from][i].valueAllowed,
+                    erc20Limits[from][i].initialValueOnBlock.sub(currentBalance) <= erc20Limits[from][i].valueAllowed,
                     "PermissionRegistry: Value limit reached"
                 );
             }

deploy/advanceTime.js

@@ -0,0 +1,12 @@
+const { time } = require("@openzeppelin/test-helpers");
+const moment = require("moment");
+
+// Sync the blockchain time to the current time
+module.exports = async () => {
+  const target = Math.floor(moment.now() / 1000);
+  console.log(`Increasing blockchain timestamp to ${target}`);
+  await time.increaseTo(target);
+};
+
+module.exports.tags = ["AdvanceTime"];
+

deploy/avatar.js

@@ -0,0 +1,37 @@
+module.exports = async ({ getNamedAccounts, deployments }) => {
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+  const deploySalt = process.env.DEPLOY_SALT;
+
+  const DAOAvatar = await hre.artifacts.require("DAOAvatar");
+
+  const daoAvatarDeploy = await deploy("DAOAvatar", {
+    name: "DAOAvatar",
+    from: deployer,
+    args: [],
+    deterministicDeployment: deploySalt,
+  });
+
+  const daoAvatar = await DAOAvatar.at(daoAvatarDeploy.address);
+
+  const controllerDeployed = await deployments.get("DAOController");
+
+  await daoAvatar.initialize(controllerDeployed.address);
+
+  if (process.env.ETHERSCAN_API_KEY && hre.network.name !== "hardhat") {
+    try {
+      await hre.run("verify:verify", {
+        address: daoAvatar.address,
+        constructorArguments: [],
+      });
+    } catch (error) {
+      console.error("Error verifying contract", error);
+    }
+  }
+
+  console.log(`DAOAvatar address ${daoAvatar.address}`);
+};
+
+module.exports.tags = ["DAOAvatar"];
+module.exports.dependencies = ["Controller"];
+

deploy/avatarScheme.js

@@ -0,0 +1,100 @@
+module.exports = async ({ getNamedAccounts, deployments }) => {
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+  const deploySalt = process.env.DEPLOY_SALT;
+
+  const AvatarScheme = await hre.artifacts.require("AvatarScheme");
+
+  const avatarSchemeDeploy = await deploy("AvatarScheme", {
+    name: "AvatarScheme",
+    from: deployer,
+    args: [],
+    deterministicDeployment: deploySalt,
+  });
+
+  const avatarScheme = await AvatarScheme.at(avatarSchemeDeploy.address);
+
+  const avatarDeployed = await deployments.get("DAOAvatar");
+  const dxdVotingMachineDeployed = await deployments.get("VotingMachine");
+  const controllerDeployed = await deployments.get("DAOController");
+  const permissionRegistryDeployed = await deployments.get(
+    "PermissionRegistry"
+  );
+
+  try {
+    await avatarScheme.initialize(
+      avatarDeployed.address,
+      dxdVotingMachineDeployed.address,
+      controllerDeployed.address,
+      permissionRegistryDeployed.address,
+      "Master Wallet",
+      5
+    );
+  } catch (e) {
+    console.warn("Avatar scheme is already deployed.");
+  }
+
+  const Controller = await hre.artifacts.require("DAOController");
+  const controller = await Controller.at(controllerDeployed.address);
+  const DXDVotingMachine = await hre.artifacts.require("VotingMachine");
+  const dxdVotingMachine = await DXDVotingMachine.at(
+    dxdVotingMachineDeployed.address
+  );
+
+  const defaultParameters = {
+    queuedVoteRequiredPercentage: 5000,
+    queuedVotePeriodLimit: 60,
+    boostedVotePeriodLimit: 60,
+    preBoostedVotePeriodLimit: 10,
+    thresholdConst: 2000,
+    quietEndingPeriod: 10,
+    daoBounty: web3.utils.toWei("0.1"),
+    boostedVoteRequiredPercentage: 100,
+  };
+
+  const defaultParametersArray = [
+    defaultParameters.queuedVoteRequiredPercentage,
+    defaultParameters.queuedVotePeriodLimit,
+    defaultParameters.boostedVotePeriodLimit,
+    defaultParameters.preBoostedVotePeriodLimit,
+    defaultParameters.thresholdConst,
+    defaultParameters.quietEndingPeriod,
+    defaultParameters.daoBounty,
+    defaultParameters.boostedVoteRequiredPercentage,
+  ];
+
+  await dxdVotingMachine.setParameters(defaultParametersArray);
+  const defaultParamsHash = await dxdVotingMachine.getParametersHash(
+    defaultParametersArray
+  );
+
+  await controller.registerScheme(
+    avatarScheme.address,
+    defaultParamsHash,
+    false,
+    true,
+    true
+  );
+
+  if (process.env.ETHERSCAN_API_KEY && hre.network.name !== "hardhat") {
+    try {
+      await hre.run("verify:verify", {
+        address: avatarScheme.address,
+        constructorArguments: [],
+      });
+    } catch (error) {
+      console.error("Error verifying contract", error);
+    }
+  }
+
+  console.log(`AvatarScheme address ${avatarScheme.address}`);
+};
+
+module.exports.tags = ["AvatarScheme"];
+module.exports.dependencies = [
+  "DAOAvatar",
+  "VotingMachine",
+  "Controller",
+  "PermissionRegistry",
+];
+

deploy/carrotGuild.js

@@ -1,5 +1,7 @@
 const moment = require("moment");
-import { deploySnapshotRepGuild } from "./deployGuild";
+const {
+  deploySnapshotRepGuild,
+} = require("../scripts/deployUtils/deployGuild");
 
 const config = {
   GUILD_ID: "CarrotGuild",

deploy/controller.js

@@ -0,0 +1,77 @@
+module.exports = async ({ getNamedAccounts, deployments }) => {
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+  const deploySalt = process.env.DEPLOY_SALT;
+
+  const Controller = await hre.artifacts.require("DAOController");
+  const DAOReputation = await hre.artifacts.require("DAOReputation");
+
+  const controllerDeploy = await deploy("DAOController", {
+    name: "Controller",
+    from: deployer,
+    args: [],
+    deterministicDeployment: deploySalt,
+  });
+
+  const controller = await Controller.at(controllerDeploy.address);
+
+  const dxdVotingMachineDeployed = await deployments.get("VotingMachine");
+  const daoReputationDeployed = await deployments.get("DAOReputation");
+  const daoReputation = await DAOReputation.at(daoReputationDeployed.address);
+  await daoReputation.transferOwnership(controller.address);
+
+  const DXDVotingMachine = await hre.artifacts.require("VotingMachine");
+  const dxdVotingMachine = await DXDVotingMachine.at(
+    dxdVotingMachineDeployed.address
+  );
+
+  const defaultParameters = {
+    queuedVoteRequiredPercentage: 5000,
+    queuedVotePeriodLimit: 60,
+    boostedVotePeriodLimit: 60,
+    preBoostedVotePeriodLimit: 10,
+    thresholdConst: 2000,
+    quietEndingPeriod: 10,
+    daoBounty: web3.utils.toWei("0.1"),
+    boostedVoteRequiredPercentage: 100,
+  };
+
+  const defaultParametersArray = [
+    defaultParameters.queuedVoteRequiredPercentage,
+    defaultParameters.queuedVotePeriodLimit,
+    defaultParameters.boostedVotePeriodLimit,
+    defaultParameters.preBoostedVotePeriodLimit,
+    defaultParameters.thresholdConst,
+    defaultParameters.quietEndingPeriod,
+    defaultParameters.daoBounty,
+    defaultParameters.boostedVoteRequiredPercentage,
+  ];
+
+  await dxdVotingMachine.setParameters(defaultParametersArray);
+  const defaultParamsHash = await dxdVotingMachine.getParametersHash(
+    defaultParametersArray
+  );
+
+  await controller.initialize(
+    deployer,
+    daoReputationDeployed.address,
+    defaultParamsHash
+  );
+
+  if (process.env.ETHERSCAN_API_KEY && hre.network.name !== "hardhat") {
+    try {
+      await hre.run("verify:verify", {
+        address: controller.address,
+        constructorArguments: [],
+      });
+    } catch (error) {
+      console.error("Error verifying contract", error);
+    }
+  }
+
+  console.log(`Controller address ${controller.address}`);
+};
+
+module.exports.tags = ["Controller"];
+module.exports.dependencies = ["DAOReputation", "VotingMachine"];
+

deploy/daoProposals.js

@@ -0,0 +1,79 @@
+module.exports = async ({ getNamedAccounts, deployments }) => {
+  const { deploy } = deployments;
+  const { deployer, tokenHolder } = await getNamedAccounts();
+
+  function testCallFrom(address, number = 1) {
+    return new web3.eth.Contract(ActionMock.abi).methods
+      .test(address, number)
+      .encodeABI();
+  }
+
+  const SOME_HASH =
+    "0x1000000000000000000000000000000000000000000000000000000000000000";
+  const TEST_TITLE = "Awesome Proposal Title";
+
+  const ActionMock = await hre.artifacts.require("ActionMock");
+  const actionMockDeployed = await deploy("ActionMock", {
+    name: "ActionMock",
+    from: deployer,
+    args: [],
+  });
+  const actionMock = await ActionMock.at(actionMockDeployed.address);
+
+  const Controller = await hre.artifacts.require("DAOController");
+  const controllerDeployed = await deployments.get("DAOController");
+  const controller = await Controller.at(controllerDeployed.address);
+
+  const avatarDeployed = await deployments.get("DAOAvatar");
+
+  const AvatarScheme = await hre.artifacts.require("AvatarScheme");
+  const avatarSchemeDeployed = await deployments.get("AvatarScheme");
+  const avatarScheme = await AvatarScheme.at(avatarSchemeDeployed.address);
+
+  const PermissionRegistry = await hre.artifacts.require("PermissionRegistry");
+  const permissionRegistryDeployed = await deployments.get(
+    "PermissionRegistry"
+  );
+  const permissionRegistry = await PermissionRegistry.at(
+    permissionRegistryDeployed.address
+  );
+  await permissionRegistry.setETHPermission(
+    avatarSchemeDeployed.address,
+    actionMockDeployed.address,
+    web3.eth.abi.encodeFunctionSignature("test(address,uint256)"),
+    0,
+    true
+  );
+
+  const callData = testCallFrom(avatarDeployed.address);
+  const callDataMintRep = await controller.contract.methods
+    .mintReputation(10, tokenHolder)
+    .encodeABI();
+
+  await avatarScheme.proposeCalls(
+    [actionMock.address, controllerDeployed.address],
+    [callData, callDataMintRep],
+    [0, 0],
+    2,
+    TEST_TITLE,
+    SOME_HASH
+  );
+  // const proposalId = await helpers.getValueFromLogs(tx, "_proposalId");
+  // await org.votingMachine.vote(proposalId, constants.YES_OPTION, 0, {
+  //   from: accounts[2],
+  // });
+  // const organizationProposal = await avatarScheme.getProposal(proposalId);
+  // assert.equal(
+  //   organizationProposal.state,
+  //   constants.WALLET_SCHEME_PROPOSAL_STATES.passed
+  // );
+};
+
+module.exports.tags = ["DAOProposals"];
+module.exports.dependencies = [
+  "AvatarScheme",
+  "DAOAvatar",
+  "Controller",
+  "PermissionRegistry",
+];
+

deploy/dxdToken.js

@@ -7,7 +7,7 @@ module.exports = async ({ getNamedAccounts, deployments }) => {
     const dxdTokenDeploy = await deploy("ERC20Mock", {
       name: "DXDToken",
       from: deployer,
-      args: [tokenHolder, hre.web3.utils.toWei("1000"), "DXD", "DXD Token", 18],
+      args: ["DXD token", "DXD", hre.web3.utils.toWei("1000"), tokenHolder],
       deterministicDeployment: deploySalt,
     });
 

deploy/dxgovGuild.js

@@ -1,5 +1,7 @@
 const moment = require("moment");
-import { deploySnapshotRepGuild } from "./deployGuild";
+const {
+  deploySnapshotRepGuild,
+} = require("../scripts/deployUtils/deployGuild");
 
 const config = {
   GUILD_ID: "DXgovGuild",

deploy/localhostGuild.js

@@ -0,0 +1,38 @@
+const moment = require("moment");
+const {
+  deploySnapshotRepGuild,
+} = require("../scripts/deployUtils/deployGuild");
+
+const config = {
+  GUILD_ID: "LocalhostGuild",
+  TOKEN_ID: "LocalhostRepToken",
+  TOKEN_NAME: "Localhost Reputation Token",
+  TOKEN_SYMBOL: "LOC",
+  guildConfig: {
+    proposalTime: moment.duration(10, "minutes").asSeconds(),
+    timeForExecution: moment.duration(7, "days").asSeconds(),
+    votingPowerPercentageForProposalExecution: 2000, // 20% voting power for proposal execution
+    votingPowerPercentageForProposalCreation: 200, // 2% voting power for proposal creation
+    name: "Localhost Guild", // guild name
+    voteGas: "0", // vote gas
+    maxGasPrice: "0", // max gas price
+    maxActiveProposals: 20, // max active proposals
+    lockTime: moment.duration(15, "minutes").asSeconds(), // lock time, not used but should be higher than proposal time
+  },
+  initialRepHolders: [
+    // default testing accounts #0, #1, #2
+    { address: "0x9578e973bba0cc33bdbc93c7f77bb3fe6d47d68a", amount: "34" },
+    { address: "0xc5b20ade9c9cd5e0cc087c62b26b815a4bc1881f", amount: "33" },
+    { address: "0xaf8eb8c3a5d9d900aa0b98e3df0bcc17d3c5f698", amount: "33" },
+  ],
+  deployExtraSalt: "localhost",
+};
+
+module.exports = hre => deploySnapshotRepGuild(config)(hre);
+module.exports.dependencies = [
+  "Create2Deployer",
+  "PermissionRegistry",
+  "GuildRegistry",
+];
+module.exports.tags = [config.GUILD_ID];
+module.exports.config = config;