ichaingov-contract-generator 1.0.0

package/index/base-contracts/GatewayRegistry.sol

@@ -0,0 +1,346 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+contract GatewayRegistry is Ownable {
+    uint256 public constant MAX_REPUTATION = 10_000;
+    enum OrgStatus {
+        Active,
+        Suspended,
+        Probation,
+        Inactive
+    }
+    enum GatewayStatus {
+        Active,
+        Suspended,
+        Revoked
+    }
+
+    struct Organization {
+        string name;
+        address wallet;
+        OrgStatus status;
+        uint256 registeredAt;
+        uint256 updatedAt;
+        bool exists;
+        uint256 reputation;
+    }
+
+    struct Gateway {
+        bytes publicKey;
+        address orgWallet;
+        string name;
+        GatewayStatus status;
+        uint256 registeredAt;
+        uint256 updatedAt;
+        bool exists;
+    }
+
+    mapping(address => Organization) public organizations;
+    mapping(bytes => Gateway) public gateways;
+    mapping(address => bytes[]) public orgGateways;
+
+    address[] public orgList;
+    bytes[] public gatewayList;
+
+    mapping(address => mapping(uint256 => uint256))
+        private _reputationSnapshots;
+    mapping(address => uint256[]) private _snapshotBlocks;
+
+    event OrganizationRegistered(
+        address indexed wallet,
+        string name,
+        uint256 timestamp
+    );
+    event OrganizationStatusChanged(
+        address indexed wallet,
+        OrgStatus oldStatus,
+        OrgStatus newStatus,
+        string reason
+    );
+    event OrganizationRemoved(address indexed wallet, string reason);
+    event GatewayRegistered(
+        bytes publicKey,
+        address indexed orgWallet,
+        uint256 timestamp
+    );
+    event GatewayStatusChanged(
+        bytes publicKey,
+        GatewayStatus oldStatus,
+        GatewayStatus newStatus,
+        string reason
+    );
+    event GatewayRemoved(bytes publicKey, string reason);
+
+    error OrgAlreadyExists(address wallet);
+    error OrgNotFound(address wallet);
+    error GatewayAlreadyExists(bytes publicKey);
+    error GatewayNotFound(bytes publicKey);
+    error InvalidAddress();
+    error InvalidPublicKey();
+    error ReputationOutOfRange(uint256 value, uint256 max);
+
+    constructor(address initialOwner) Ownable(initialOwner) {}
+
+    function registerOrganization(
+        address wallet,
+        string calldata name,
+        uint256 initialReputation
+    ) external onlyOwner {
+        if (wallet == address(0)) revert InvalidAddress();
+        if (organizations[wallet].exists) revert OrgAlreadyExists(wallet);
+        if (initialReputation > MAX_REPUTATION)
+            revert ReputationOutOfRange(initialReputation, MAX_REPUTATION);
+
+        organizations[wallet] = Organization({
+            name: name,
+            wallet: wallet,
+            status: OrgStatus.Active,
+            registeredAt: block.number,
+            updatedAt: block.number,
+            exists: true,
+            reputation: initialReputation
+        });
+
+        _takeSnapshot(wallet);
+        orgList.push(wallet);
+        emit OrganizationRegistered(wallet, name, block.number);
+    }
+
+    function setOrganizationStatus(
+        address wallet,
+        OrgStatus newStatus,
+        string calldata reason
+    ) external onlyOwner {
+        if (!organizations[wallet].exists) revert OrgNotFound(wallet);
+        OrgStatus old = organizations[wallet].status;
+        organizations[wallet].status = newStatus;
+        organizations[wallet].updatedAt = block.number;
+        emit OrganizationStatusChanged(wallet, old, newStatus, reason);
+    }
+
+    function updateOrganizationName(
+        address wallet,
+        string calldata newName
+    ) external onlyOwner {
+        if (!organizations[wallet].exists) revert OrgNotFound(wallet);
+        organizations[wallet].name = newName;
+        organizations[wallet].updatedAt = block.number;
+    }
+
+    function removeOrganization(
+        address wallet,
+        string calldata reason
+    ) external onlyOwner {
+        if (!organizations[wallet].exists) revert OrgNotFound(wallet);
+        for (uint256 i = 0; i < orgList.length; i++) {
+            if (orgList[i] == wallet) {
+                orgList[i] = orgList[orgList.length - 1];
+                orgList.pop();
+                break;
+            }
+        }
+        delete organizations[wallet];
+        emit OrganizationRemoved(wallet, reason);
+    }
+
+    function registerGateway(
+        bytes calldata publicKey,
+        address orgWallet,
+        string calldata name
+    ) external onlyOwner {
+        if (publicKey.length == 0) revert InvalidPublicKey();
+        if (!organizations[orgWallet].exists) revert OrgNotFound(orgWallet);
+        if (gateways[publicKey].exists) revert GatewayAlreadyExists(publicKey);
+
+        gateways[publicKey] = Gateway({
+            publicKey: publicKey,
+            orgWallet: orgWallet,
+            name: name,
+            status: GatewayStatus.Active,
+            registeredAt: block.number,
+            updatedAt: block.number,
+            exists: true
+        });
+        orgGateways[orgWallet].push(publicKey);
+        gatewayList.push(publicKey);
+        emit GatewayRegistered(publicKey, orgWallet, block.number);
+    }
+
+    function setGatewayStatus(
+        bytes calldata publicKey,
+        GatewayStatus newStatus,
+        string calldata reason
+    ) external onlyOwner {
+        if (!gateways[publicKey].exists) revert GatewayNotFound(publicKey);
+        GatewayStatus old = gateways[publicKey].status;
+        gateways[publicKey].status = newStatus;
+        gateways[publicKey].updatedAt = block.number;
+        emit GatewayStatusChanged(publicKey, old, newStatus, reason);
+    }
+
+    function removeGateway(
+        bytes calldata publicKey,
+        string calldata reason
+    ) external onlyOwner {
+        if (!gateways[publicKey].exists) revert GatewayNotFound(publicKey);
+        address orgWallet = gateways[publicKey].orgWallet;
+        bytes[] storage og = orgGateways[orgWallet];
+        for (uint256 i = 0; i < og.length; i++) {
+            if (keccak256(og[i]) == keccak256(publicKey)) {
+                og[i] = og[og.length - 1];
+                og.pop();
+                break;
+            }
+        }
+        for (uint256 i = 0; i < gatewayList.length; i++) {
+            if (keccak256(gatewayList[i]) == keccak256(publicKey)) {
+                gatewayList[i] = gatewayList[gatewayList.length - 1];
+                gatewayList.pop();
+                break;
+            }
+        }
+        delete gateways[publicKey];
+        emit GatewayRemoved(publicKey, reason);
+    }
+
+    function setReputation(address wallet, uint256 newRep) external onlyOwner {
+        if (!organizations[wallet].exists) revert OrgNotFound(wallet);
+        if (newRep > MAX_REPUTATION)
+            revert ReputationOutOfRange(newRep, MAX_REPUTATION);
+        organizations[wallet].reputation = newRep;
+        organizations[wallet].updatedAt = block.number;
+        _takeSnapshot(wallet);
+    }
+
+    function increaseReputation(
+        address wallet,
+        uint256 amount
+    ) external onlyOwner {
+        if (!organizations[wallet].exists) revert OrgNotFound(wallet);
+        uint256 old = organizations[wallet].reputation;
+        uint256 next = old + amount > MAX_REPUTATION
+            ? MAX_REPUTATION
+            : old + amount;
+        organizations[wallet].reputation = next;
+        organizations[wallet].updatedAt = block.number;
+        _takeSnapshot(wallet);
+    }
+
+    function decreaseReputation(
+        address wallet,
+        uint256 amount
+    ) external onlyOwner {
+        if (!organizations[wallet].exists) revert OrgNotFound(wallet);
+        uint256 old = organizations[wallet].reputation;
+        uint256 next = old < amount ? 0 : old - amount;
+        organizations[wallet].reputation = next;
+        organizations[wallet].updatedAt = block.number;
+        _takeSnapshot(wallet);
+    }
+
+    function _takeSnapshot(address wallet) internal {
+        uint256[] storage blocks = _snapshotBlocks[wallet];
+        if (blocks.length == 0 || blocks[blocks.length - 1] < block.number) {
+            blocks.push(block.number);
+            _reputationSnapshots[wallet][block.number] = organizations[wallet]
+                .reputation;
+        }
+    }
+
+    function getReputationAt(
+        address wallet,
+        uint256 blockNumber
+    ) external view returns (uint256) {
+        uint256[] storage blocks = _snapshotBlocks[wallet];
+
+        if (blocks.length == 0) return organizations[wallet].reputation;
+        if (blockNumber < blocks[0]) return 0;
+
+        uint256 low = 0;
+        uint256 high = blocks.length - 1;
+        while (low < high) {
+            uint256 mid = (low + high + 1) / 2;
+            if (blocks[mid] <= blockNumber) low = mid;
+            else high = mid - 1;
+        }
+        return _reputationSnapshots[wallet][blocks[low]];
+    }
+
+    function getOrganization(
+        address wallet
+    ) external view returns (Organization memory) {
+        if (!organizations[wallet].exists) revert OrgNotFound(wallet);
+        return organizations[wallet];
+    }
+
+    function getGateway(
+        bytes calldata publicKey
+    ) external view returns (Gateway memory) {
+        if (!gateways[publicKey].exists) revert GatewayNotFound(publicKey);
+        return gateways[publicKey];
+    }
+
+    function getOrgGateways(
+        address orgWallet
+    ) external view returns (bytes[] memory) {
+        return orgGateways[orgWallet];
+    }
+
+    function getOrgCount() external view returns (uint256) {
+        return orgList.length;
+    }
+
+    function getGatewayCount() external view returns (uint256) {
+        return gatewayList.length;
+    }
+
+    function isOrgActive(address wallet) external view returns (bool) {
+        return
+            organizations[wallet].exists &&
+            organizations[wallet].status == OrgStatus.Active;
+    }
+
+    function isGatewayActive(
+        bytes calldata publicKey
+    ) external view returns (bool) {
+        return
+            gateways[publicKey].exists &&
+            gateways[publicKey].status == GatewayStatus.Active;
+    }
+
+    function getOrgsByStatus(
+        OrgStatus status
+    ) external view returns (address[] memory) {
+        uint256 count = 0;
+        for (uint256 i = 0; i < orgList.length; i++)
+            if (organizations[orgList[i]].status == status) count++;
+        address[] memory result = new address[](count);
+        uint256 idx = 0;
+        for (uint256 i = 0; i < orgList.length; i++)
+            if (organizations[orgList[i]].status == status)
+                result[idx++] = orgList[i];
+        return result;
+    }
+
+    function getAllOrganizations()
+        external
+        view
+        returns (Organization[] memory)
+    {
+        Organization[] memory all = new Organization[](orgList.length);
+        for (uint256 i = 0; i < orgList.length; i++) {
+            all[i] = organizations[orgList[i]];
+        }
+        return all;
+    }
+
+    function getAllGateways() external view returns (Gateway[] memory) {
+        Gateway[] memory all = new Gateway[](gatewayList.length);
+        for (uint256 i = 0; i < gatewayList.length; i++) {
+            all[i] = gateways[gatewayList[i]];
+        }
+        return all;
+    }
+}

package/index/base-contracts/Governance.sol

@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.27;
+
+import {Governor}                    from "@openzeppelin/contracts/governance/Governor.sol";
+import {GovernorCountingSimple}      from "@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol";
+import {GovernorSettings}            from "@openzeppelin/contracts/governance/extensions/GovernorSettings.sol";
+import {GovernorVotes}               from "@openzeppelin/contracts/governance/extensions/GovernorVotes.sol";
+import {GovernorVotesQuorumFraction} from "@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol";
+import {IVotes}                      from "@openzeppelin/contracts/governance/utils/IVotes.sol";
+import {Math}                        from "@openzeppelin/contracts/utils/math/Math.sol";
+import {GatewayRegistry}             from "./GatewayRegistry.sol";
+
+contract Governance is
+    Governor,
+    GovernorSettings,
+    GovernorCountingSimple,
+    GovernorVotes,
+    GovernorVotesQuorumFraction
+{
+    enum VotingSystem {
+        TokenBased,          // 0: ERC20Votes weight (default)
+        Quadratic,           // 1: sqrt of ERC20Votes weight
+        WeightedReputation   // 2: tokenVotes boosted by GatewayRegistry reputation
+    }
+
+    /// only needed for WeightedReputation, address(0) otherwise
+    GatewayRegistry public gatewayRegistry;
+    VotingSystem public defaultVotingSystem;
+
+    mapping(uint256 => VotingSystem) public proposalVotingSystem;
+
+    /// @notice Transient context: set at start of _castVote, read by _getVotes.
+    /// Safe because _castVote → super._castVote → _getVotes all run in one call stack.
+    /// Reset after each vote to keep storage clean between transactions.
+    VotingSystem private _activeVotingSystem;
+
+    error RegistryNotSet();
+
+    constructor(
+        string memory governorName,
+        IVotes _token,
+        uint32  _votingDelay,
+        uint32  _votingPeriod,
+        uint256 _proposalThreshold,
+        uint256 _quorumFraction,
+        VotingSystem _defaultVotingSystem,
+        GatewayRegistry _gatewayRegistry 
+    )
+        Governor(governorName)
+        GovernorSettings(_votingDelay, _votingPeriod, _proposalThreshold)
+        GovernorVotes(_token)
+        GovernorVotesQuorumFraction(_quorumFraction)
+    {
+        if (
+            _defaultVotingSystem == VotingSystem.WeightedReputation &&
+            address(_gatewayRegistry) == address(0)
+        ) revert RegistryNotSet();
+
+        defaultVotingSystem = _defaultVotingSystem;
+        gatewayRegistry     = _gatewayRegistry;
+    }
+
+    function setDefaultVotingSystem(VotingSystem newSystem) external onlyGovernance {
+        if (
+            newSystem == VotingSystem.WeightedReputation &&
+            address(gatewayRegistry) == address(0)
+        ) revert RegistryNotSet();
+
+        defaultVotingSystem = newSystem;
+    }
+
+    function setGatewayRegistry(GatewayRegistry newRegistry) external onlyGovernance {
+        gatewayRegistry = newRegistry;
+    }
+
+
+    function propose(
+        address[] memory targets,
+        uint256[] memory values,
+        bytes[] memory calldatas,
+        string memory description
+    ) public override returns (uint256) {
+        uint256 proposalId = super.propose(targets, values, calldatas, description);
+        _assignVotingSystem(proposalId, defaultVotingSystem);
+        return proposalId;
+    }
+
+    function _assignVotingSystem(uint256 proposalId, VotingSystem vs) internal {
+        proposalVotingSystem[proposalId] = vs;
+    }
+
+    function _castVote(
+        uint256 proposalId,
+        address account,
+        uint8 support,
+        string memory reason,
+        bytes memory params
+    ) internal override returns (uint256) {
+        _activeVotingSystem = proposalVotingSystem[proposalId];
+        uint256 weight = super._castVote(proposalId, account, support, reason, params);
+        delete _activeVotingSystem;
+        return weight;
+    }
+
+
+    function _getVotes(
+        address account,
+        uint256 timepoint,
+        bytes memory params
+    )
+        internal view
+        override(Governor, GovernorVotes)
+        returns (uint256)
+    {
+        uint256 tokenVotes = super._getVotes(account, timepoint, params);
+        VotingSystem vs = _activeVotingSystem;
+
+        if (vs == VotingSystem.TokenBased) {
+            return tokenVotes;
+        }
+
+        if (vs == VotingSystem.Quadratic) {
+            return Math.sqrt(tokenVotes);
+        }
+
+        // WeightedReputation: using 10_000 base avoids floating point
+        if (vs == VotingSystem.WeightedReputation) {
+            if (address(gatewayRegistry) == address(0)) return tokenVotes;
+            uint256 reputation = gatewayRegistry.getReputationAt(account, timepoint);
+            return tokenVotes * (10_000 + reputation) / 10_000;
+        }
+
+        return tokenVotes;
+    }
+
+    function votingDelay()
+        public view override(Governor, GovernorSettings) returns (uint256)
+    { return super.votingDelay(); }
+
+    function votingPeriod()
+        public view override(Governor, GovernorSettings) returns (uint256)
+    { return super.votingPeriod(); }
+
+    function proposalThreshold()
+        public view override(Governor, GovernorSettings) returns (uint256)
+    { return super.proposalThreshold(); }
+
+    function quorum(uint256 blockNumber)
+        public view override(Governor, GovernorVotesQuorumFraction) returns (uint256)
+    { return super.quorum(blockNumber); }
+
+}

package/index/base-contracts/GovernanceWithTimelock.sol

@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.27;
+
+import {Governor}                    from "@openzeppelin/contracts/governance/Governor.sol";
+import {TimelockController}          from "@openzeppelin/contracts/governance/TimelockController.sol";
+import {GovernorCountingSimple}      from "@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol";
+import {GovernorSettings}            from "@openzeppelin/contracts/governance/extensions/GovernorSettings.sol";
+import {GovernorTimelockControl}     from "@openzeppelin/contracts/governance/extensions/GovernorTimelockControl.sol";
+import {GovernorVotes}               from "@openzeppelin/contracts/governance/extensions/GovernorVotes.sol";
+import {GovernorVotesQuorumFraction} from "@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol";
+import {IVotes}                      from "@openzeppelin/contracts/governance/utils/IVotes.sol";
+import {Math}                        from "@openzeppelin/contracts/utils/math/Math.sol";
+import {GatewayRegistry}             from "./GatewayRegistry.sol";
+
+contract GovernanceWithTimelock is
+    Governor,
+    GovernorSettings,
+    GovernorCountingSimple,
+    GovernorVotes,
+    GovernorVotesQuorumFraction,
+    GovernorTimelockControl
+{
+
+    enum VotingSystem {
+        TokenBased,          // 0: standard ERC20Votes weight (default)
+        Quadratic,           // 1: sqrt(tokenVotes) — reduces whale dominance
+        WeightedReputation   // 2: tokenVotes boosted by GatewayRegistry reputation
+    }
+
+
+    /// @notice Optional — only needed for WeightedReputation, address(0) otherwise
+    GatewayRegistry public gatewayRegistry;
+
+    /// @notice Voting system applied to proposals created via propose()
+    VotingSystem public defaultVotingSystem;
+
+    /// @notice voting System of a given proposal
+    mapping(uint256 => VotingSystem) public proposalVotingSystem;
+
+    /// @notice Transient context: set at start of _castVote, read by _getVotes.
+    /// Safe because _castVote → super._castVote → _getVotes all run in one call stack.
+    /// Reset after each vote to keep storage clean between transactions.
+    VotingSystem private _activeVotingSystem;
+
+    error RegistryNotSet();
+
+    constructor(
+        string memory governorName,
+        IVotes _token,
+        TimelockController _timelock,
+        uint32  _votingDelay,
+        uint32  _votingPeriod,
+        uint256 _proposalThreshold,
+        uint256 _quorumFraction,
+        VotingSystem _defaultVotingSystem,
+        GatewayRegistry _gatewayRegistry   // pass address(0) for TokenBased / Quadratic
+    )
+        Governor(governorName)
+        GovernorSettings(_votingDelay, _votingPeriod, _proposalThreshold)
+        GovernorVotes(_token)
+        GovernorVotesQuorumFraction(_quorumFraction)
+        GovernorTimelockControl(_timelock)
+    {
+        if (
+            _defaultVotingSystem == VotingSystem.WeightedReputation &&
+            address(_gatewayRegistry) == address(0)
+        ) revert RegistryNotSet();
+
+        defaultVotingSystem = _defaultVotingSystem;
+        gatewayRegistry     = _gatewayRegistry;
+    }
+
+    function setDefaultVotingSystem(VotingSystem newSystem) external onlyGovernance {
+        if (
+            newSystem == VotingSystem.WeightedReputation &&
+            address(gatewayRegistry) == address(0)
+        ) revert RegistryNotSet();
+
+        defaultVotingSystem = newSystem;
+    }
+
+    function setGatewayRegistry(GatewayRegistry newRegistry) external onlyGovernance {
+        gatewayRegistry = newRegistry;
+    }
+
+    function propose(
+        address[] memory targets,
+        uint256[] memory values,
+        bytes[] memory calldatas,
+        string memory description
+    ) public override returns (uint256) {
+        uint256 proposalId = super.propose(targets, values, calldatas, description);
+        _assignVotingSystem(proposalId, defaultVotingSystem);
+        return proposalId;
+    }
+
+    function _assignVotingSystem(uint256 proposalId, VotingSystem vs) internal {
+        proposalVotingSystem[proposalId] = vs;
+    }
+
+    function _castVote(
+        uint256 proposalId,
+        address account,
+        uint8 support,
+        string memory reason,
+        bytes memory params
+    ) internal override returns (uint256) {
+        _activeVotingSystem = proposalVotingSystem[proposalId];
+
+        uint256 weight = super._castVote(proposalId, account, support, reason, params);
+        delete _activeVotingSystem;
+
+        return weight;
+    }
+
+    /// @notice Core weight calculation — routes to the correct formula
+    ///         based on _activeVotingSystem set by _castVote above.
+    function _getVotes(
+        address account,
+        uint256 timepoint,
+        bytes memory params
+    )
+        internal view
+        override(Governor, GovernorVotes)
+        returns (uint256)
+    {
+        uint256 tokenVotes = super._getVotes(account, timepoint, params);
+
+        VotingSystem vs = _activeVotingSystem;
+
+        if (vs == VotingSystem.TokenBased) {
+            return tokenVotes;
+        }
+
+        if (vs == VotingSystem.Quadratic) {
+            return Math.sqrt(tokenVotes);
+        }
+
+        // Using 10_000 avoids floating point arithmetic
+        if (vs == VotingSystem.WeightedReputation) {
+            if (address(gatewayRegistry) == address(0)) return tokenVotes;
+            uint256 reputation = gatewayRegistry.getReputationAt(account, timepoint);
+            return tokenVotes * (10_000 + reputation) / 10_000;
+        }
+
+        return tokenVotes;
+    }
+
+    function state(uint256 proposalId)
+        public view override(Governor, GovernorTimelockControl) returns (ProposalState)
+    { return super.state(proposalId); }
+
+    function proposalNeedsQueuing(uint256 proposalId)
+        public view override(Governor, GovernorTimelockControl) returns (bool)
+    { return super.proposalNeedsQueuing(proposalId); }
+
+    function _queueOperations(
+        uint256 proposalId, address[] memory targets,
+        uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash
+    )
+        internal override(Governor, GovernorTimelockControl) returns (uint48)
+    { return super._queueOperations(proposalId, targets, values, calldatas, descriptionHash); }
+
+    function _executeOperations(
+        uint256 proposalId, address[] memory targets,
+        uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash
+    )
+        internal override(Governor, GovernorTimelockControl)
+    { super._executeOperations(proposalId, targets, values, calldatas, descriptionHash); }
+
+    function _cancel(
+        address[] memory targets, uint256[] memory values,
+        bytes[] memory calldatas, bytes32 descriptionHash
+    )
+        internal override(Governor, GovernorTimelockControl) returns (uint256)
+    { return super._cancel(targets, values, calldatas, descriptionHash); }
+
+    function _executor()
+        internal view override(Governor, GovernorTimelockControl) returns (address)
+    { return super._executor(); }
+
+
+    function votingDelay()
+        public view override(Governor, GovernorSettings) returns (uint256)
+    { return super.votingDelay(); }
+
+    function votingPeriod()
+        public view override(Governor, GovernorSettings) returns (uint256)
+    { return super.votingPeriod(); }
+
+    function proposalThreshold()
+        public view override(Governor, GovernorSettings) returns (uint256)
+    { return super.proposalThreshold(); }
+
+    function quorum(uint256 blockNumber)
+        public view override(Governor, GovernorVotesQuorumFraction) returns (uint256)
+    { return super.quorum(blockNumber); }
+}