@venusprotocol/governance-contracts 1.4.0-dev.1 → 1.4.0-dev.10

package/contracts/Governance/TimelockV8.sol

@@ -0,0 +1,229 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+import { ensureNonzeroAddress } from "@venusprotocol/solidity-utilities/contracts/validators.sol";
+
+/**
+ * @title TimelockV8
+ * @author Venus
+ * @notice The Timelock contract using solidity V8.
+ * This contract also differs from the original timelock because it has a virtual function to get minimum delays
+ * and allow test deployments to override the value.
+ */
+contract TimelockV8 {
+    /// @notice Event emitted when a new admin is accepted
+    event NewAdmin(address indexed newAdmin);
+
+    /// @notice Event emitted when a new admin is proposed
+    event NewPendingAdmin(address indexed newPendingAdmin);
+
+    /// @notice Event emitted when a new admin is proposed
+    event NewDelay(uint256 indexed newDelay);
+
+    /// @notice Event emitted when a proposal transaction has been cancelled
+    event CancelTransaction(
+        bytes32 indexed txHash,
+        address indexed target,
+        uint256 value,
+        string signature,
+        bytes data,
+        uint256 eta
+    );
+
+    /// @notice Event emitted when a proposal transaction has been executed
+    event ExecuteTransaction(
+        bytes32 indexed txHash,
+        address indexed target,
+        uint256 value,
+        string signature,
+        bytes data,
+        uint256 eta
+    );
+
+    /// @notice Event emitted when a proposal transaction has been queued
+    event QueueTransaction(
+        bytes32 indexed txHash,
+        address indexed target,
+        uint256 value,
+        string signature,
+        bytes data,
+        uint256 eta
+    );
+
+    /// @notice Required period to execute a proposal transaction
+    uint256 private constant DEFAULT_GRACE_PERIOD = 14 days;
+
+    /// @notice Minimum amount of time a proposal transaction must be queued
+    uint256 private constant DEFAULT_MINIMUM_DELAY = 1 hours;
+
+    /// @notice Maximum amount of time a proposal transaction must be queued
+    uint256 private constant DEFAULT_MAXIMUM_DELAY = 30 days;
+
+    /// @notice Timelock admin authorized to queue and execute transactions
+    address public admin;
+
+    /// @notice Account proposed as the next admin
+    address public pendingAdmin;
+
+    /// @notice Period for a proposal transaction to be queued
+    uint256 public delay;
+
+    /// @notice Mapping of queued transactions
+    mapping(bytes32 => bool) public queuedTransactions;
+
+    constructor(address admin_, uint256 delay_) {
+        require(delay_ >= MINIMUM_DELAY(), "Timelock::constructor: Delay must exceed minimum delay.");
+        require(delay_ <= MAXIMUM_DELAY(), "Timelock::setDelay: Delay must not exceed maximum delay.");
+        ensureNonzeroAddress(admin_);
+
+        admin = admin_;
+        delay = delay_;
+    }
+
+    fallback() external payable {}
+
+    /**
+     * @notice Setter for the transaction queue delay
+     * @param delay_ The new delay period for the transaction queue
+     */
+    function setDelay(uint256 delay_) public {
+        require(msg.sender == address(this), "Timelock::setDelay: Call must come from Timelock.");
+        require(delay_ >= MINIMUM_DELAY(), "Timelock::setDelay: Delay must exceed minimum delay.");
+        require(delay_ <= MAXIMUM_DELAY(), "Timelock::setDelay: Delay must not exceed maximum delay.");
+        delay = delay_;
+
+        emit NewDelay(delay);
+    }
+
+    function GRACE_PERIOD() public view virtual returns (uint256) {
+        return DEFAULT_GRACE_PERIOD;
+    }
+
+    function MINIMUM_DELAY() public view virtual returns (uint256) {
+        return DEFAULT_MINIMUM_DELAY;
+    }
+
+    function MAXIMUM_DELAY() public view virtual returns (uint256) {
+        return DEFAULT_MAXIMUM_DELAY;
+    }
+
+    /**
+     * @notice Method for accepting a proposed admin
+     */
+    function acceptAdmin() public {
+        require(msg.sender == pendingAdmin, "Timelock::acceptAdmin: Call must come from pendingAdmin.");
+        admin = msg.sender;
+        pendingAdmin = address(0);
+
+        emit NewAdmin(admin);
+    }
+
+    /**
+     * @notice Method to propose a new admin authorized to call timelock functions. This should be the Governor Contract
+     * @param pendingAdmin_ Address of the proposed admin
+     */
+    function setPendingAdmin(address pendingAdmin_) public {
+        require(msg.sender == address(this), "Timelock::setPendingAdmin: Call must come from Timelock.");
+        ensureNonzeroAddress(pendingAdmin_);
+        pendingAdmin = pendingAdmin_;
+
+        emit NewPendingAdmin(pendingAdmin);
+    }
+
+    /**
+     * @notice Called for each action when queuing a proposal
+     * @param target Address of the contract with the method to be called
+     * @param value Native token amount sent with the transaction
+     * @param signature Ssignature of the function to be called
+     * @param data Arguments to be passed to the function when called
+     * @param eta Timestamp after which the transaction can be executed
+     * @return Hash of the queued transaction
+     */
+    function queueTransaction(
+        address target,
+        uint256 value,
+        string memory signature,
+        bytes memory data,
+        uint256 eta
+    ) public returns (bytes32) {
+        require(msg.sender == admin, "Timelock::queueTransaction: Call must come from admin.");
+        require(
+            eta >= getBlockTimestamp() + delay,
+            "Timelock::queueTransaction: Estimated execution block must satisfy delay."
+        );
+
+        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
+        queuedTransactions[txHash] = true;
+
+        emit QueueTransaction(txHash, target, value, signature, data, eta);
+        return txHash;
+    }
+
+    /**
+     * @notice Called to cancel a queued transaction
+     * @param target Address of the contract with the method to be called
+     * @param value Native token amount sent with the transaction
+     * @param signature Ssignature of the function to be called
+     * @param data Arguments to be passed to the function when called
+     * @param eta Timestamp after which the transaction can be executed
+     */
+    function cancelTransaction(
+        address target,
+        uint256 value,
+        string memory signature,
+        bytes memory data,
+        uint256 eta
+    ) public {
+        require(msg.sender == admin, "Timelock::cancelTransaction: Call must come from admin.");
+
+        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
+        queuedTransactions[txHash] = false;
+
+        emit CancelTransaction(txHash, target, value, signature, data, eta);
+    }
+
+    /**
+     * @notice Called to execute a queued transaction
+     * @param target Address of the contract with the method to be called
+     * @param value Native token amount sent with the transaction
+     * @param signature Ssignature of the function to be called
+     * @param data Arguments to be passed to the function when called
+     * @param eta Timestamp after which the transaction can be executed
+     */
+    function executeTransaction(
+        address target,
+        uint256 value,
+        string memory signature,
+        bytes memory data,
+        uint256 eta
+    ) public payable returns (bytes memory) {
+        require(msg.sender == admin, "Timelock::executeTransaction: Call must come from admin.");
+
+        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
+        require(queuedTransactions[txHash], "Timelock::executeTransaction: Transaction hasn't been queued.");
+        require(getBlockTimestamp() >= eta, "Timelock::executeTransaction: Transaction hasn't surpassed time lock.");
+        require(getBlockTimestamp() <= eta + GRACE_PERIOD(), "Timelock::executeTransaction: Transaction is stale.");
+
+        queuedTransactions[txHash] = false;
+
+        bytes memory callData;
+
+        if (bytes(signature).length == 0) {
+            callData = data;
+        } else {
+            callData = abi.encodePacked(bytes4(keccak256(bytes(signature))), data);
+        }
+
+        // solium-disable-next-line security/no-call-value
+        (bool success, bytes memory returnData) = target.call{ value: value }(callData);
+        require(success, "Timelock::executeTransaction: Transaction execution reverted.");
+
+        emit ExecuteTransaction(txHash, target, value, signature, data, eta);
+
+        return returnData;
+    }
+
+    function getBlockTimestamp() internal view returns (uint256) {
+        // solium-disable-next-line security/no-block-members
+        return block.timestamp;
+    }
+}

package/contracts/legacy/GovenorBravoV1.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)
+            }
+        }
+    }
+}

package/contracts/test/TestTimelockV8.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+import { TimelockV8 } from "../Governance/TimelockV8.sol";
+
+contract TestTimelockV8 is TimelockV8 {
+    constructor(address admin_, uint256 delay_) public TimelockV8(admin_, delay_) {}
+
+    function GRACE_PERIOD() public view override returns (uint256) {
+        return 1;
+    }
+
+    function MINIMUM_DELAY() public view override returns (uint256) {
+        return 1;
+    }
+
+    function MAXIMUM_DELAY() public view override returns (uint256) {
+        return 1 hours;
+    }
+}

package/deploy/001-timelock.ts

@@ -0,0 +1,74 @@
+import { DeployFunction } from "hardhat-deploy/types";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+import { SUPPORTED_NETWORKS } from "../helpers/deploy/constants";
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployments, getNamedAccounts } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  const networkName = hre.network.name as SUPPORTED_NETWORKS;
+  const live = hre.network.live;
+
+  const delayConfig = {
+    hardhat: {
+      normal: 600,
+      fast: 300,
+      critical: 100,
+    },
+    bscmainnet: {
+      normal: 172800,
+      fast: 21600,
+      critical: 3600,
+    },
+    bsctestnet: {
+      normal: 600,
+      fast: 300,
+      critical: 100,
+    },
+    sepolia: {
+      normal: 600,
+      fast: 300,
+      critical: 100,
+    },
+    ethereum: {
+      normal: 172800,
+      fast: 21600,
+      critical: 3600,
+    },
+    opbnbtestnet: {
+      normal: 600,
+      fast: 300,
+      critical: 100,
+    },
+  };
+
+  await deploy("NormalTimelock", {
+    contract: live ? "TimelockV8" : "TestTimelockV8",
+    from: deployer,
+    args: [deployer, delayConfig[networkName].normal],
+    log: true,
+    autoMine: true,
+  });
+
+  await deploy("FastTrackTimelock", {
+    contract: live ? "TimelockV8" : "TestTimelockV8",
+    from: deployer,
+    args: [deployer, delayConfig[networkName].fast],
+    log: true,
+    autoMine: true,
+  });
+
+  await deploy("CriticalTimelock", {
+    contract: live ? "TimelockV8" : "TestTimelockV8",
+    from: deployer,
+    args: [deployer, delayConfig[networkName].critical],
+    log: true,
+    autoMine: true,
+  });
+};
+
+func.tags = ["Timelock"];
+
+export default func;

package/deploy/002-access-control.ts

@@ -0,0 +1,39 @@
+import { ethers } from "hardhat";
+import { DeployFunction } from "hardhat-deploy/types";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+import { SUPPORTED_NETWORKS } from "../helpers/deploy/constants";
+import { getAcmAdminAccount } from "../helpers/deploy/deploymentUtils";
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployments, getNamedAccounts } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  const acmDeployment = await deploy("AccessControlManager", {
+    from: deployer,
+    args: [],
+    log: true,
+    autoMine: true,
+  });
+
+  const acm = await ethers.getContractAt("AccessControlManager", acmDeployment.address);
+
+  if (hre.network.live) {
+    const networkName = hre.network.name as SUPPORTED_NETWORKS;
+    const adminAccount = await getAcmAdminAccount(networkName);
+    console.log(`Granting DEFAULT_ADMIN_ROLE to ${adminAccount} for ${networkName} network`);
+    await acm.grantRole(acm.DEFAULT_ADMIN_ROLE(), adminAccount);
+
+    console.log(`Renouncing DEFAULT_ADMIN_ROLE from deployer (${deployer}) for ${hre.network.name} network`);
+    await acm.renounceRole(acm.DEFAULT_ADMIN_ROLE(), deployer);
+  } else {
+    const timelockAddress = (await ethers.getContract("NormalTimelock")).address;
+
+    await acm.grantRole(acm.DEFAULT_ADMIN_ROLE(), timelockAddress);
+  }
+};
+
+func.tags = ["AccessControl"];
+
+export default func;

package/deployments/bscmainnet_addresses.json

@@ -0,0 +1,16 @@
+{
+  "name": "bscmainnet",
+  "chainId": "56",
+  "addresses": {
+    "AccessControlManager": "0x4788629abc6cfca10f9f969efdeaa1cf70c23555",
+    "CriticalTimelock": "0x213c446ec11e45b15a6E29C1C1b402B8897f606d",
+    "FastTrackTimelock": "0x555ba73dB1b006F3f2C7dB7126d6e4343aDBce02",
+    "GovernorAlpha": "0x406f48f47D25E9caa29f17e7Cfbd1dc6878F078f",
+    "GovernorAlpha2": "0x388313BfEFEE8ddfeAD55b585F62812293Cf3A60",
+    "GovernorBravoDelegate": "0x360ac19648efC29d2b7b70baC227C35e909272Fd",
+    "GovernorBravoDelegator": "0x2d56dC077072B53571b8252008C60e945108c75a",
+    "GovernorBravoDelegator_Implementation": "0x360ac19648efc29d2b7b70bac227c35e909272fd",
+    "GovernorBravoDelegator_Proxy": "0x2d56dC077072B53571b8252008C60e945108c75a",
+    "NormalTimelock": "0x939bD8d64c0A9583A7Dcea9933f7b21697ab6396"
+  }
+}

package/deployments/bsctestnet_addresses.json

@@ -0,0 +1,15 @@
+{
+  "name": "bsctestnet",
+  "chainId": "97",
+  "addresses": {
+    "AccessControlManager": "0x45f8a08F534f34A97187626E05d4b6648Eeaa9AA",
+    "CriticalTimelock": "0x23B893a7C45a5Eb8c8C062b9F32d0D2e43eD286D",
+    "FastTrackTimelock": "0x3CFf21b7AF8390fE68799D58727d3b4C25a83cb6",
+    "GovernorAlpha": "0x7df10b2118eb04d9806b15198019f83741a9f8f4",
+    "GovernorBravoDelegate": "0x4baF88AbA7f86f6540728BEF454b224C5d2215e7",
+    "GovernorBravoDelegator": "0x5573422A1a59385C247ec3a66B93B7C08eC2f8f2",
+    "GovernorBravoDelegator_Implementation": "0x4baf88aba7f86f6540728bef454b224c5d2215e7",
+    "GovernorBravoDelegator_Proxy": "0x5573422A1a59385C247ec3a66B93B7C08eC2f8f2",
+    "NormalTimelock": "0xce10739590001705F7FF231611ba4A48B2820327"
+  }
+}

package/deployments/ethereum/.chainId

@@ -0,0 +1 @@
+1