ichaingov-contract-generator 1.0.0

package/index/base-contracts/PolicyRegistry.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+contract PolicyRegistry is Ownable {
+
+    struct Parameter {
+        string  key;
+        uint256 value;
+        uint256 createdAt;
+        uint256 updatedAt;
+        bool    exists;
+    }
+
+    mapping(string => Parameter) public parameters;
+    string[] public parameterKeys;
+
+    event ParameterAdded(string key, uint256 value, uint256 timestamp);
+    event ParameterUpdated(string key, uint256 oldValue, uint256 newValue, uint256 timestamp);
+    event ParameterRemoved(string key, uint256 timestamp);
+
+    error ParameterAlreadyExists(string key);
+    error ParameterNotFound(string key);
+    error EmptyKey();
+
+    constructor(address initialOwner) Ownable(initialOwner) {}
+
+    function addParameter(
+        string calldata key,
+        uint256 value
+    ) external onlyOwner {
+        if (bytes(key).length == 0) revert EmptyKey();
+        if (parameters[key].exists) revert ParameterAlreadyExists(key);
+
+        parameters[key] = Parameter({
+            key:       key,
+            value:     value,
+            createdAt: block.timestamp,
+            updatedAt: block.timestamp,
+            exists:    true
+        });
+
+        parameterKeys.push(key);
+        emit ParameterAdded(key, value, block.timestamp);
+    }
+
+    function setParameter(
+        string calldata key,
+        uint256 newValue
+    ) external onlyOwner {
+        if (!parameters[key].exists) revert ParameterNotFound(key);
+
+        uint256 oldValue = parameters[key].value;
+        parameters[key].value     = newValue;
+        parameters[key].updatedAt = block.timestamp;
+
+        emit ParameterUpdated(key, oldValue, newValue, block.timestamp);
+    }
+
+    function removeParameter(string calldata key) external onlyOwner {
+        if (!parameters[key].exists) revert ParameterNotFound(key);
+
+        for (uint256 i = 0; i < parameterKeys.length; i++) {
+            if (keccak256(bytes(parameterKeys[i])) == keccak256(bytes(key))) {
+                parameterKeys[i] = parameterKeys[parameterKeys.length - 1];
+                parameterKeys.pop();
+                break;
+            }
+        }
+
+        delete parameters[key];
+        emit ParameterRemoved(key, block.timestamp);
+    }
+
+    // functions to be called from outside of this contract (testing)
+
+    function getParameter(string calldata key)
+        external view
+        returns (Parameter memory)
+    {
+        if (!parameters[key].exists) revert ParameterNotFound(key);
+        return parameters[key];
+    }
+
+    function getValue(string calldata key)
+        external view
+        returns (uint256)
+    {
+        if (!parameters[key].exists) revert ParameterNotFound(key);
+        return parameters[key].value;
+    }
+
+    function getAllParameters()
+        external view
+        returns (Parameter[] memory)
+    {
+        Parameter[] memory result = new Parameter[](parameterKeys.length);
+        for (uint256 i = 0; i < parameterKeys.length; i++) {
+            result[i] = parameters[parameterKeys[i]];
+        }
+        return result;
+    }
+
+    function getParameterCount() external view returns (uint256) {
+        return parameterKeys.length;
+    }
+
+    function parameterExists(string calldata key) external view returns (bool) {
+        return parameters[key].exists;
+    }
+}

package/index/base-contracts/Timelock.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/governance/TimelockController.sol";
+
+contract Timelock is TimelockController {
+    // minDelay: delay in seconds before execution
+    // proposers: addresses allowed to queue proposals
+    // executors: addresses allowed to execute proposals (empty = anyone)
+    // admin: initial admin
+    constructor(
+        uint256 minDelay,
+        address[] memory proposers,
+        address[] memory executors,
+        address admin
+    )
+        TimelockController(minDelay, proposers, executors, admin)
+    {}
+}

package/index/base-contracts/Token.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";
+import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+
+contract Token is ERC20, EIP712, ERC20Votes {
+
+    address public governance;
+
+    constructor(
+        string memory name,
+        string memory symbol,
+        uint256 supply,
+        address dao
+    ) ERC20(name, symbol) EIP712(name, "1") {
+        governance = dao;
+        _mint(dao, supply * 10 ** decimals());
+        
+    }
+
+    modifier onlyGovernance() {
+        require(msg.sender == governance, "Token: not governance");
+        _;
+    }
+
+    function reclaimTokensToAddress(address account, address recipient) external onlyGovernance {
+        uint256 amount = balanceOf(account);
+        if (amount == 0) return;
+        _transfer(account, recipient, amount);
+    }
+
+    function burnAllTokensFromAccount(address account) external onlyGovernance {
+        _burn(account, balanceOf(account));
+    }
+
+    function transferOwnership(address newGovernance) external onlyGovernance {
+        require(newGovernance != address(0), "Token: zero address");
+        governance = newGovernance;
+    }
+
+    function _update(address from, address to, uint256 amount)
+        internal
+        override(ERC20, ERC20Votes)
+    {
+        super._update(from, to, amount);
+    }
+}

package/index/generateDeploy.js

@@ -0,0 +1,59 @@
+import fs from "fs-extra";
+import path from "path";
+import Handlebars from "handlebars";
+import { encodeValue } from "../core/encodeParameter.js";
+import { mapVotingSystemIndex } from "./mappers.js";
+
+export async function generateDeploy(config) {
+  const templatePath = path.join(
+    path.dirname(new URL(import.meta.url).pathname),
+    "../index/templates/deploy.js.hbs"
+  );
+
+  if (!await fs.pathExists(templatePath)) {
+    throw new Error(`Deploy template not found: ${templatePath}`);
+  }
+  const protocolParameters = (config.protocolParameters || []).map(p => ({
+    key: p.key,
+    value: encodeValue(p.value).toString(),
+    originalValue: p.value
+  }));
+
+  let index = mapVotingSystemIndex(config.governance.votingSystem);
+
+  const data = {
+    daoName: config.name,
+    tokenName: config.tokenomics.name,
+    tokenSymbol: config.tokenomics.symbol,
+    totalSupply: config.tokenomics.supply,
+    tokensPerMember: config.tokenomics.defaultMemberTokens,
+    organizations: config.organizations.map(org => ({
+      wallet: org.address,
+      name: org.name,
+      reputation: org.reputation || 0,
+      gateways: (org.gateways || []).map(gw => ({
+        publicKey: typeof gw === "string" ? gw : gw.publicKey,
+        name: typeof gw === "string" ? "" : gw.name
+      }))
+    })),
+    isTimelock: config.timelock.enabled,
+    timelockDelay: config.timelock.minDelay,
+    contractName: config.timelock.enabled ? "GovernanceWithTimelock" : "Governance",
+    votingDelay: config.governance.votingDelay,
+    votingPeriod: config.governance.votingPeriod,
+    proposalThreshold: config.governance.proposalThreshold,
+    quorumFraction: config.governance.quorumFraction,
+    votingSystemIndex: index,
+    protocolParameters: protocolParameters,
+    isWeightedReputation: index === 2,
+  };
+
+  const raw = await fs.readFile(templatePath, "utf-8");
+  const template = Handlebars.compile(raw);
+  const output = template(data);
+
+  await fs.ensureDir("scripts");
+  const outPath = "scripts/deploy.js";
+  await fs.writeFile(outPath, output);
+  console.log(`Generated ${outPath}`);
+}

package/index/generator.js

@@ -0,0 +1,37 @@
+import fs   from "fs-extra";
+import path from "path";
+
+function packageRoot() {
+  return path.dirname(new URL(import.meta.url).pathname);
+}
+
+function baseContractsDir() {
+  return path.join(packageRoot(), "../index/base-contracts");
+}
+
+export async function generate(config) {
+  const isTimelock = config.timelock.enabled;
+  const sourceFile = isTimelock ? "GovernanceWithTimelock.sol" : "Governance.sol";
+
+  await fs.ensureDir("contracts");
+
+  const baseSrc = baseContractsDir();
+  const baseDest = "contracts";
+
+  if (!await fs.pathExists(baseSrc)) {
+    throw new Error(`Base contracts directory not found: ${baseSrc}`);
+  }
+
+  const files = await fs.readdir(baseSrc);
+  for (const file of files) {
+    if (!file.endsWith(".sol")) continue;
+    if (file === "Timelock.sol" && !isTimelock) {
+      console.log(`Skipped ${file} (timelock not enabled)`);
+      continue;
+    }
+    if (file === "GovernanceWithTimelock.sol" && !isTimelock) continue;
+    if (file === "Governance.sol" && isTimelock) continue;
+
+    await fs.copy(path.join(baseSrc, file), path.join(baseDest, file), { overwrite: true });
+  }
+}

package/index/mappers.js

@@ -0,0 +1,19 @@
+export function mapVotingSystem(vs) {
+  switch (vs) {
+    case "token-based":          return "VotingSystem.TokenBased";
+    case "quadratic":            return "VotingSystem.Quadratic";
+    case "weighted-reputation":  return "VotingSystem.WeightedReputation";
+    default:
+      throw new Error(`Unknown votingSystem: "${vs}"`);
+  }
+}
+
+export function mapVotingSystemIndex(vs) {
+  switch (vs) {
+    case "token-based":         return 0;
+    case "quadratic":           return 1;
+    case "weighted-reputation": return 2;
+    default:
+      throw new Error(`Unknown votingSystem: "${vs}"`);
+  }
+}

package/index/templates/deploy.js.hbs

@@ -0,0 +1,136 @@
+const { ethers } = require("hardhat");
+
+async function main() {
+  const [deployer] = await ethers.getSigners();
+  console.log("Deployer:", deployer.address);
+  console.log("Balance:", ethers.formatEther(await deployer.provider.getBalance(deployer.address)), "ETH\n");
+
+  console.log("Deploying Token...");
+  const Token = await ethers.getContractFactory("Token");
+  const token = await Token.deploy(
+    "{{tokenName}}",
+    "{{tokenSymbol}}",
+    {{totalSupply}},
+    deployer.address
+  );
+  await token.waitForDeployment();
+  const tokenAddr = await token.getAddress();
+  console.log("  Token:", tokenAddr);
+
+  {{#if isTimelock}}
+  console.log("Deploying Timelock...");
+  const Timelock = await ethers.getContractFactory("Timelock");
+  const timelock = await Timelock.deploy(
+    {{timelockDelay}},
+    [],
+    [],
+    deployer.address
+  );
+  await timelock.waitForDeployment();
+  const timelockAddr = await timelock.getAddress();
+  console.log("  Timelock:", timelockAddr);
+  {{/if}}
+
+  console.log("Deploying GatewayRegistry...");
+  const GatewayRegistry = await ethers.getContractFactory("GatewayRegistry");
+  const registry = await GatewayRegistry.deploy(deployer.address);
+  await registry.waitForDeployment();
+  const registryAddr = await registry.getAddress();
+  console.log("  GatewayRegistry:", registryAddr);
+
+  console.log("Deploying PolicyRegistry...");
+  const PolicyRegistry = await ethers.getContractFactory("PolicyRegistry");
+  const policy = await PolicyRegistry.deploy(deployer.address);
+  await policy.waitForDeployment();
+  const policyAddr = await policy.getAddress();
+  console.log("  PolicyRegistry:", policyAddr);
+
+  console.log("\nRegistering organizations...");
+  const tokensPerMember = ethers.parseEther("{{tokensPerMember}}");
+
+  {{#each organizations}}
+  await registry.registerOrganization("{{this.wallet}}", "{{this.name}}", {{this.reputation}});
+  await token.transfer("{{this.wallet}}", tokensPerMember);
+  console.log("  Registered: {{this.name}} ({{this.wallet}})");
+
+  {{#each this.gateways}}
+  await registry.registerGateway("{{this.publicKey}}", "{{../this.wallet}}","{{this.name}}");
+  console.log("    Gateway registered: {{this.publicKey}} for {{../this.name}}");
+  {{/each}}
+  {{/each}}
+
+  console.log("\nAdding protocol parameters...");
+  {{#each protocolParameters}}
+  // {{this.key}} = {{this.originalValue}} (encoded as {{this.value}})
+  await policy.addParameter("{{this.key}}", {{this.value}}n);
+  {{/each}}
+
+  const remaining = await token.balanceOf(deployer.address);
+  {{#if isTimelock}}
+  await token.transfer(timelockAddr, remaining);
+  console.log("  timelock:", ethers.formatEther(remaining), "{{tokenSymbol}}");
+  {{else}}
+  console.warn("  Warning: No timelock configured; treasury remains with deployer.");
+  {{/if}}
+
+  console.log("isWeightedReputation:", {{isWeightedReputation}});
+
+  console.log("\nDeploying {{contractName}}...");
+  const Governor = await ethers.getContractFactory("{{contractName}}");
+  const governor = await Governor.deploy(
+    "{{daoName}}",
+    tokenAddr,
+    {{#if isTimelock}}timelockAddr,{{/if}}
+    {{votingDelay}},
+    {{votingPeriod}},
+    {{proposalThreshold}},
+    {{quorumFraction}},
+    {{votingSystemIndex}},
+    {{#if isWeightedReputation}}registryAddr{{else}}ethers.ZeroAddress{{/if}}
+  );
+  await governor.waitForDeployment();
+  const governorAddr = await governor.getAddress();
+  console.log("  {{contractName}}:", governorAddr);
+
+  {{#if isTimelock}}
+  console.log("\nConfiguring timelock roles...");
+  const PROPOSER_ROLE  = await timelock.PROPOSER_ROLE();
+  const CANCELLER_ROLE = await timelock.CANCELLER_ROLE();
+  const EXECUTOR_ROLE  = await timelock.EXECUTOR_ROLE();
+  const ADMIN_ROLE     = await timelock.DEFAULT_ADMIN_ROLE();
+
+  await timelock.grantRole(PROPOSER_ROLE,  governorAddr);
+  await timelock.grantRole(CANCELLER_ROLE, governorAddr);
+  await timelock.grantRole(EXECUTOR_ROLE,  ethers.ZeroAddress);
+  console.log("  PROPOSER  -> governor");
+  console.log("  CANCELLER -> governor");
+  console.log("  EXECUTOR  -> open (address(0))");
+
+  console.log("\nTransferring ownership of gateway registry, policy registry and token contracts to timelock...");
+  await registry.transferOwnership(timelockAddr);
+  await policy.transferOwnership(timelockAddr);
+  await token.transferOwnership(timelockAddr);
+
+  console.log("Revoking deployer admin role...");
+  await timelock.revokeRole(ADMIN_ROLE, deployer.address);
+  console.log("  Deployer has no remaining privileges");
+  {{else}}
+  await registry.transferOwnership(governorAddr);
+  await policy.transferOwnership(governorAddr);
+  await token.transferOwnership(governorAddr);
+  console.log("  Ownership transferred directly to governor (no timelock).");
+{{/if}}
+  console.log("\nDeployment summary:");
+  console.log("  Token:           ", tokenAddr);
+  {{#if isTimelock}}
+  console.log("  Timelock:        ", timelockAddr);
+  {{/if}}
+  console.log("  GatewayRegistry: ", registryAddr);
+  console.log("  PolicyRegistry:  ", policyAddr);
+  console.log("  Governor:        ", governorAddr);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/index/templates/template-config.json

@@ -0,0 +1,63 @@
+{
+  "name": "TestDao",
+  "tokenomics": {
+    "name": "TestDao",
+    "symbol": "RDAO",
+    "supply": 1000000,
+    "defaultMemberTokens": 1000
+  },
+  "organizations": [
+    {
+      "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+      "name": "Organization A",
+      "gateways": [
+        {
+          "publicKey": "0x02e68acfc0253a10620dff079256c9efb7df3a7eb5b4dc8d03aefc3cbd5c20a1b0",
+          "name": "GatewayA1"
+        },
+        {
+          "publicKey": "0x03b17e6b5f7b87e2b0ef3e1c4d942f19a8d1f5e3c9b4872e3e9e3e3e3e3e3e3e",
+          "name": "GatewayA2"
+        }
+      ]
+    },
+    {
+      "address": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+      "name": "Organization B",
+      "gateways": [
+        {
+          "publicKey": "0x027a1b2c3d4e5f60718293a4b5c6d7e8f90123456789abcdef0123456789abcdef",
+          "name": "GatewayB1"
+        }
+      ]
+    },
+    {
+      "address": "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
+      "name": "Organization C",
+      "gateways": [
+        {
+          "publicKey": "0x03f123456789abcdef0123456789abcdef0123456789abcdef0123456789abcd",
+          "name": "GatewayC1"
+        }
+      ]
+    }
+  ],
+  "governance": {
+    "votingPeriod": 5,
+    "votingDelay": 1,
+    "proposalThreshold": 0,
+    "quorumFraction": 0,
+    "votingSystem": "token-based"
+  },
+  "timelock": {
+    "enabled": false,
+    "minDelay": 0
+  },
+  "protocolParameters": [
+    { "key": "satp.version", "value": "v02" },
+    { "key": "satp.crash.version", "value": "v02" },
+    { "key": "satp.session.lockExpirationTime", "value": "34" },
+    { "key": "signingAlgorithm", "value": "SECP256K1" },
+    { "key": "claimFormat", "value": "3" }
+  ]
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "ichaingov-contract-generator",
+  "version": "1.0.0",
+  "description": "ichaingov contract generator — generates governance contracts from config.json",
+  "type": "module",
+  "bin": {
+    "ichaingov-contract-generator": "./bin/cli.js"
+  },
+  "license": "MIT",
+  "keywords": [
+    "dao",
+    "governance"
+  ],
+  "author": "Ana Sa",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bh19cp/ichaingov-contract-generator.git"
+  },
+  "files": [
+    "bin",
+    "core",
+    "index"
+  ],
+  "dependencies": {
+    "@openzeppelin/contracts": "^5.6.1",
+    "ethers": "^6.16.0",
+    "fs-extra": "^11.2.0",
+    "handlebars": "^4.7.8",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@nomicfoundation/hardhat-toolbox": "^4.0.0",
+    "hardhat": "^2.28.6"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}