@venusprotocol/governance-contracts 2.11.1-dev.2 → 2.12.0-dev.1

package/artifacts/contracts/legacy/GovernorBravoInterfacesV2.sol/GovernorBravoEventsV2.json

@@ -0,0 +1,312 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "GovernorBravoEventsV2",
+  "sourceName": "contracts/legacy/GovernorBravoInterfacesV2.sol",
+  "abi": [
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "oldAdmin",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "newAdmin",
+          "type": "address"
+        }
+      ],
+      "name": "NewAdmin",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "oldGuardian",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "newGuardian",
+          "type": "address"
+        }
+      ],
+      "name": "NewGuardian",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "oldImplementation",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "newImplementation",
+          "type": "address"
+        }
+      ],
+      "name": "NewImplementation",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "oldPendingAdmin",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "newPendingAdmin",
+          "type": "address"
+        }
+      ],
+      "name": "NewPendingAdmin",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "id",
+          "type": "uint256"
+        }
+      ],
+      "name": "ProposalCanceled",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "id",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "proposer",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "address[]",
+          "name": "targets",
+          "type": "address[]"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256[]",
+          "name": "values",
+          "type": "uint256[]"
+        },
+        {
+          "indexed": false,
+          "internalType": "string[]",
+          "name": "signatures",
+          "type": "string[]"
+        },
+        {
+          "indexed": false,
+          "internalType": "bytes[]",
+          "name": "calldatas",
+          "type": "bytes[]"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "startBlock",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "endBlock",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "string",
+          "name": "description",
+          "type": "string"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint8",
+          "name": "proposalType",
+          "type": "uint8"
+        }
+      ],
+      "name": "ProposalCreated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "id",
+          "type": "uint256"
+        }
+      ],
+      "name": "ProposalExecuted",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "oldMaxOperations",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "newMaxOperations",
+          "type": "uint256"
+        }
+      ],
+      "name": "ProposalMaxOperationsUpdated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "id",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "eta",
+          "type": "uint256"
+        }
+      ],
+      "name": "ProposalQueued",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "oldProposalThreshold",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "newProposalThreshold",
+          "type": "uint256"
+        }
+      ],
+      "name": "ProposalThresholdSet",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "voter",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "proposalId",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint8",
+          "name": "support",
+          "type": "uint8"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "votes",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "string",
+          "name": "reason",
+          "type": "string"
+        }
+      ],
+      "name": "VoteCast",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "oldVotingDelay",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "newVotingDelay",
+          "type": "uint256"
+        }
+      ],
+      "name": "VotingDelaySet",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "oldVotingPeriod",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "newVotingPeriod",
+          "type": "uint256"
+        }
+      ],
+      "name": "VotingPeriodSet",
+      "type": "event"
+    }
+  ],
+  "bytecode": "0x6080604052348015600f57600080fd5b50604c80601d6000396000f3fe6080604052600080fdfea365627a7a723158200f63769915acc84dc0c56af4ee01a78605ccfcbb62ce538b18a3cff9de8874f96c6578706572696d656e74616cf564736f6c63430005100040",
+  "deployedBytecode": "0x6080604052600080fdfea365627a7a723158200f63769915acc84dc0c56af4ee01a78605ccfcbb62ce538b18a3cff9de8874f96c6578706572696d656e74616cf564736f6c63430005100040",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/contracts/Governance/GovernorBravoDelegate.sol

@@ -70,7 +70,7 @@ import "./GovernorBravoInterfaces.sol";
  * The delegation of votes happens through the `XVSVault` contract by calling the `delegate` or `delegateBySig` functions. These same functions can revert
  * vote delegation by calling the same function with a value of `0`.
  */
-contract GovernorBravoDelegate is GovernorBravoDelegateStorageV2, GovernorBravoEvents {
+contract GovernorBravoDelegate is GovernorBravoDelegateStorageV3, GovernorBravoEvents {
     /// @notice The name of this contract
     string public constant name = "Venus Governor Bravo";
 
@@ -80,18 +80,6 @@ contract GovernorBravoDelegate is GovernorBravoDelegateStorageV2, GovernorBravoE
     /// @notice The maximum setable proposal threshold
     uint public constant MAX_PROPOSAL_THRESHOLD = 300000e18; //300,000 Xvs
 
-    /// @notice The minimum setable voting period
-    uint public constant MIN_VOTING_PERIOD = 20 * 60 * 3; // About 3 hours, 3 secs per block
-
-    /// @notice The max setable voting period
-    uint public constant MAX_VOTING_PERIOD = 20 * 60 * 24 * 14; // About 2 weeks, 3 secs per block
-
-    /// @notice The min setable voting delay
-    uint public constant MIN_VOTING_DELAY = 1;
-
-    /// @notice The max setable voting delay
-    uint public constant MAX_VOTING_DELAY = 20 * 60 * 24 * 7; // About 1 week, 3 secs per block
-
     /// @notice The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed
     uint public constant quorumVotes = 600000e18; // 600,000 = 2% of Xvs
 
@@ -110,20 +98,21 @@ contract GovernorBravoDelegate is GovernorBravoDelegateStorageV2, GovernorBravoE
      */
     function initialize(
         address xvsVault_,
+        ValidationParams memory validationParams_,
         ProposalConfig[] memory proposalConfigs_,
         TimelockInterface[] memory timelocks,
         address guardian_
     ) public {
         require(address(proposalTimelocks[0]) == address(0), "GovernorBravo::initialize: cannot initialize twice");
         require(msg.sender == admin, "GovernorBravo::initialize: admin only");
-        require(xvsVault_ != address(0), "GovernorBravo::initialize: invalid xvs address");
+        require(xvsVault_ != address(0), "GovernorBravo::initialize: invalid xvs vault address");
         require(guardian_ != address(0), "GovernorBravo::initialize: invalid guardian");
         require(
-            timelocks.length == uint8(ProposalType.CRITICAL) + 1,
+            timelocks.length == getGovernanceRouteCount(),
             "GovernorBravo::initialize:number of timelocks should match number of governance routes"
         );
         require(
-            proposalConfigs_.length == uint8(ProposalType.CRITICAL) + 1,
+            proposalConfigs_.length == getGovernanceRouteCount(),
             "GovernorBravo::initialize:number of proposal configs should match number of governance routes"
         );
 
@@ -131,37 +120,94 @@ contract GovernorBravoDelegate is GovernorBravoDelegateStorageV2, GovernorBravoE
         proposalMaxOperations = 10;
         guardian = guardian_;
 
-        //Set parameters for each Governance Route
+        // Set parameters for each Governance Route
+        setValidationParams(validationParams_);
+        setProposalConfigs(proposalConfigs_);
+
+        uint256 arrLength = timelocks.length;
+        for (uint256 i; i < arrLength; ++i) {
+            require(address(timelocks[i]) != address(0), "GovernorBravo::initialize:invalid timelock address");
+            proposalTimelocks[i] = timelocks[i];
+        }
+    }
+
+    /**
+     ** @notice Sets the validation parameters for voting delay and voting period
+     ** @param newValidationParams Struct containing new minimum and maximum voting period and delay
+     */
+    function setValidationParams(ValidationParams memory newValidationParams) public {
+        require(msg.sender == admin, "GovernorBravo::setValidationParams: admin only");
+        require(
+            newValidationParams.minVotingPeriod > 0 &&
+                newValidationParams.minVotingDelay > 0 &&
+                newValidationParams.minVotingDelay < newValidationParams.maxVotingDelay &&
+                newValidationParams.minVotingPeriod < newValidationParams.maxVotingPeriod,
+            "GovernorBravo::setValidationParams: invalid params"
+        );
+        emit SetValidationParams(
+            validationParams.minVotingPeriod,
+            newValidationParams.minVotingPeriod,
+            validationParams.maxVotingPeriod,
+            newValidationParams.maxVotingPeriod,
+            validationParams.minVotingDelay,
+            newValidationParams.minVotingDelay,
+            validationParams.maxVotingDelay,
+            newValidationParams.maxVotingDelay
+        );
+        validationParams = newValidationParams;
+    }
+
+    /**
+     ** @notice Sets the configuration for different proposal types
+     ** @dev Requires validationParams to be configured before also it will set proposal config for all proposal types
+     ** @param proposalConfigs_ Array of proposal configuration structs to update
+     */
+    function setProposalConfigs(ProposalConfig[] memory proposalConfigs_) public {
+        require(msg.sender == admin, "GovernorBravo::setProposalConfigs: admin only");
+        require(
+            validationParams.minVotingPeriod > 0 &&
+                validationParams.maxVotingPeriod > 0 &&
+                validationParams.minVotingDelay > 0 &&
+                validationParams.maxVotingDelay > 0,
+            "GovernorBravo::setProposalConfigs: validation params not configured yet"
+        );
         uint256 arrLength = proposalConfigs_.length;
+        require(
+            arrLength == getGovernanceRouteCount(),
+            "GovernorBravo::setProposalConfigs: invalid proposal config length"
+        );
         for (uint256 i; i < arrLength; ++i) {
             require(
-                proposalConfigs_[i].votingPeriod >= MIN_VOTING_PERIOD,
-                "GovernorBravo::initialize: invalid min voting period"
+                proposalConfigs_[i].votingPeriod >= validationParams.minVotingPeriod,
+                "GovernorBravo::setProposalConfigs: invalid min voting period"
             );
             require(
-                proposalConfigs_[i].votingPeriod <= MAX_VOTING_PERIOD,
-                "GovernorBravo::initialize: invalid max voting period"
+                proposalConfigs_[i].votingPeriod <= validationParams.maxVotingPeriod,
+                "GovernorBravo::setProposalConfigs: invalid max voting period"
             );
             require(
-                proposalConfigs_[i].votingDelay >= MIN_VOTING_DELAY,
-                "GovernorBravo::initialize: invalid min voting delay"
+                proposalConfigs_[i].votingDelay >= validationParams.minVotingDelay,
+                "GovernorBravo::setProposalConfigs: invalid min voting delay"
             );
             require(
-                proposalConfigs_[i].votingDelay <= MAX_VOTING_DELAY,
-                "GovernorBravo::initialize: invalid max voting delay"
+                proposalConfigs_[i].votingDelay <= validationParams.maxVotingDelay,
+                "GovernorBravo::setProposalConfigs: invalid max voting delay"
             );
             require(
                 proposalConfigs_[i].proposalThreshold >= MIN_PROPOSAL_THRESHOLD,
-                "GovernorBravo::initialize: invalid min proposal threshold"
+                "GovernorBravo::setProposalConfigs: invalid min proposal threshold"
             );
             require(
                 proposalConfigs_[i].proposalThreshold <= MAX_PROPOSAL_THRESHOLD,
-                "GovernorBravo::initialize: invalid max proposal threshold"
+                "GovernorBravo::setProposalConfigs: invalid max proposal threshold"
             );
-            require(address(timelocks[i]) != address(0), "GovernorBravo::initialize:invalid timelock address");
 
             proposalConfigs[i] = proposalConfigs_[i];
-            proposalTimelocks[i] = timelocks[i];
+            emit SetProposalConfigs(
+                proposalConfigs_[i].votingPeriod,
+                proposalConfigs_[i].votingDelay,
+                proposalConfigs_[i].proposalThreshold
+            );
         }
     }
 
@@ -500,7 +546,7 @@ contract GovernorBravoDelegate is GovernorBravoDelegateStorageV2, GovernorBravoE
         require(initialProposalId == 0, "GovernorBravo::_initiate: can only initiate once");
         proposalCount = GovernorAlphaInterface(governorAlpha).proposalCount();
         initialProposalId = proposalCount;
-        for (uint256 i; i < uint8(ProposalType.CRITICAL) + 1; ++i) {
+        for (uint256 i; i < getGovernanceRouteCount(); ++i) {
             proposalTimelocks[i].acceptAdmin();
         }
     }
@@ -580,4 +626,8 @@ contract GovernorBravoDelegate is GovernorBravoDelegateStorageV2, GovernorBravoE
         }
         return chainId;
     }
+
+    function getGovernanceRouteCount() internal pure returns (uint8) {
+        return uint8(ProposalType.CRITICAL) + 1;
+    }
 }

package/contracts/Governance/GovernorBravoInterfaces.sol

@@ -61,6 +61,21 @@ contract GovernorBravoEvents {
 
     /// @notice Emitted when the maximum number of operations in one proposal is updated
     event ProposalMaxOperationsUpdated(uint oldMaxOperations, uint newMaxOperations);
+
+    /// @notice Emitted when the new validation params are set
+    event SetValidationParams(
+        uint256 oldMinVotingPeriod,
+        uint256 newMinVotingPeriod,
+        uint256 oldmaxVotingPeriod,
+        uint256 newmaxVotingPeriod,
+        uint256 oldminVotingDelay,
+        uint256 newminVotingDelay,
+        uint256 oldmaxVotingDelay,
+        uint256 newmaxVotingDelay
+    );
+
+    /// @notice Emitted when new Proposal configs added
+    event SetProposalConfigs(uint256 votingPeriod, uint256 votingDelay, uint256 proposalThreshold);
 }
 
 /**
@@ -179,7 +194,7 @@ contract GovernorBravoDelegateStorageV1 is GovernorBravoDelegatorStorage {
 
 /**
  * @title GovernorBravoDelegateStorageV2
- * @dev For future upgrades, do not change GovernorBravoDelegateStorageV1. Create a new
+ * @dev For future upgrades, do not change GovernorBravoDelegateStorageV2. Create a new
  * contract which implements GovernorBravoDelegateStorageV2 and following the naming convention
  * GovernorBravoDelegateStorageVX.
  */
@@ -206,6 +221,23 @@ contract GovernorBravoDelegateStorageV2 is GovernorBravoDelegateStorageV1 {
     mapping(uint => TimelockInterface) public proposalTimelocks;
 }
 
+/**
+ * @title GovernorBravoDelegateStorageV3
+ * @dev For future upgrades, do not change GovernorBravoDelegateStorageV3. Create a new
+ * contract which implements GovernorBravoDelegateStorageV3 and following the naming convention
+ * GovernorBravoDelegateStorageVX.
+ */
+contract GovernorBravoDelegateStorageV3 is GovernorBravoDelegateStorageV2 {
+    struct ValidationParams {
+        uint256 minVotingPeriod;
+        uint256 maxVotingPeriod;
+        uint256 minVotingDelay;
+        uint256 maxVotingDelay;
+    }
+    /// @notice Stores the current minimum and maximum values of voting delay and voting period
+    ValidationParams public validationParams;
+}
+
 /**
  * @title TimelockInterface
  * @author Venus

package/contracts/legacy/GovenorBravoV2.sol

@@ -0,0 +1,97 @@
+pragma solidity ^0.5.16;
+pragma experimental ABIEncoderV2;
+
+import "./GovernorBravoInterfaces.sol";
+
+/**
+ * @title GovernorBravoDelegator
+ * @author Venus
+ * @notice The `GovernorBravoDelegator` contract.
+ */
+contract GovernorBravoDelegatorV1 is GovernorBravoDelegatorStorage, GovernorBravoEventsV1 {
+    constructor(
+        address timelock_,
+        address xvsVault_,
+        address admin_,
+        address implementation_,
+        uint votingPeriod_,
+        uint votingDelay_,
+        uint proposalThreshold_,
+        address guardian_
+    ) public {
+        // Admin set to msg.sender for initialization
+        admin = msg.sender;
+
+        delegateTo(
+            implementation_,
+            abi.encodeWithSignature(
+                "initialize(address,address,uint256,uint256,uint256,address)",
+                timelock_,
+                xvsVault_,
+                votingPeriod_,
+                votingDelay_,
+                proposalThreshold_,
+                guardian_
+            )
+        );
+
+        _setImplementation(implementation_);
+
+        admin = admin_;
+    }
+
+    /**
+     * @notice Called by the admin to update the implementation of the delegator
+     * @param implementation_ The address of the new implementation for delegation
+     */
+    function _setImplementation(address implementation_) public {
+        require(msg.sender == admin, "GovernorBravoDelegator::_setImplementation: admin only");
+        require(
+            implementation_ != address(0),
+            "GovernorBravoDelegator::_setImplementation: invalid implementation address"
+        );
+
+        address oldImplementation = implementation;
+        implementation = implementation_;
+
+        emit NewImplementation(oldImplementation, implementation);
+    }
+
+    /**
+     * @notice Internal method to delegate execution to another contract
+     * @dev It returns to the external caller whatever the implementation returns or forwards reverts
+     * @param callee The contract to delegatecall
+     * @param data The raw data to delegatecall
+     */
+    function delegateTo(address callee, bytes memory data) internal {
+        (bool success, bytes memory returnData) = callee.delegatecall(data);
+        assembly {
+            if eq(success, 0) {
+                revert(add(returnData, 0x20), returndatasize)
+            }
+        }
+    }
+
+    /**
+     * @dev Delegates execution to an implementation contract.
+     * It returns to the external caller whatever the implementation returns
+     * or forwards reverts.
+     */
+    function() external payable {
+        // delegate all other functions to current implementation
+        (bool success, ) = implementation.delegatecall(msg.data);
+
+        assembly {
+            let free_mem_ptr := mload(0x40)
+            returndatacopy(free_mem_ptr, 0, returndatasize)
+
+            switch success
+            case 0 {
+                revert(free_mem_ptr, returndatasize)
+            }
+            default {
+                return(free_mem_ptr, returndatasize)
+            }
+        }
+    }
+}