Feat/token voting target improvements

packages/contracts/deploy/20_new_version/23_publish.ts

@@ -142,8 +142,12 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
           createVersion: {
             _release: VERSION.release,
             _pluginSetup: setup.address,
-            _buildMetadata: toHex(buildMetadataURI),
-            _releaseMetadata: toHex(releaseMetadataURI),
+            _buildMetadata: ethers.utils.hexlify(
+              ethers.utils.toUtf8Bytes(buildMetadataURI)
+            ),
+            _releaseMetadata: ethers.utils.hexlify(
+              ethers.utils.toUtf8Bytes(releaseMetadataURI)
+            ),
           },
         },
       ],

packages/contracts/hardhat.config.ts

@@ -156,7 +156,7 @@ const config: HardhatUserConfig = {
     deploy: './deploy',
   },
   mocha: {
-    timeout: 60_000,
+    timeout: 6000000,
   },
   solidity: {
     version: '0.8.17',

packages/contracts/src/IMajorityVoting.sol

@@ -36,6 +36,10 @@ interface IMajorityVoting {
     /// @return The support threshold parameter.
     function supportThreshold() external view returns (uint32);
 
+    /// @notice Returns the min approval value stored configured.
+    /// @return The minimal approval value.
+    function minApproval() external view returns (uint256);
+
     /// @notice Returns the minimum participation parameter stored in the voting settings.
     /// @return The minimum participation parameter.
     function minParticipation() external view returns (uint32);
@@ -61,6 +65,13 @@ interface IMajorityVoting {
     /// @return Returns `true` if the participation is greater than the minimum participation and `false` otherwise.
     function isMinParticipationReached(uint256 _proposalId) external view returns (bool);
 
+    /// @notice Checks if the min approval value defined as:
+    ///$$\texttt{minApproval} = \frac{N_\text{yes}}{N_\text{total}}$$
+    /// for a proposal vote is greater or equal than the minimum approval value.
+    /// @param _proposalId The ID of the proposal.
+    /// @return Returns `true` if the participation is greater than the minimum participation and `false` otherwise.
+    function isMinApprovalReached(uint256 _proposalId) external view returns (bool);
+
     /// @notice Checks if an account can participate on a proposal vote. This can be because the vote
     /// - has not started,
     /// - has ended,

packages/contracts/src/MajorityVotingBase.sol

@@ -12,6 +12,9 @@ import {ProposalUpgradeable} from "@aragon/osx-commons-contracts/src/plugin/exte
 import {RATIO_BASE, RatioOutOfBounds} from "@aragon/osx-commons-contracts/src/utils/math/Ratio.sol";
 import {PluginUUPSUpgradeable} from "@aragon/osx-commons-contracts/src/plugin/PluginUUPSUpgradeable.sol";
 import {IDAO} from "@aragon/osx-commons-contracts/src/dao/IDAO.sol";
+import {IProposal} from "@aragon/osx-commons-contracts/src/plugin/extensions/proposal/IProposal.sol";
+import {Action} from "@aragon/osx-commons-contracts/src/executors/IExecutor.sol";
+import {MetadataExtensionUpgradeable} from "@aragon/osx-commons-contracts/src/utils/metadata/MetadataExtensionUpgradeable.sol";
 
 import {IMajorityVoting} from "./IMajorityVoting.sol";
 
@@ -120,6 +123,7 @@ abstract contract MajorityVotingBase is
     IMajorityVoting,
     Initializable,
     ERC165Upgradeable,
+    MetadataExtensionUpgradeable,
     PluginUUPSUpgradeable,
     ProposalUpgradeable
 {
@@ -165,15 +169,18 @@ abstract contract MajorityVotingBase is
     /// @param voters The votes casted by the voters.
     /// @param actions The actions to be executed when the proposal passes.
     /// @param allowFailureMap A bitmap allowing the proposal to succeed, even if individual actions might revert.
+    /// @param minApprovalPower The minimum amount of yes votes power needed for the proposal advance.
     /// If the bit at index `i` is 1, the proposal succeeds even if the `i`th action reverts.
     /// A failure map value of 0 requires every action to not revert.
     struct Proposal {
         bool executed;
         ProposalParameters parameters;
         Tally tally;
         mapping(address => IMajorityVoting.VoteOption) voters;
-        IDAO.Action[] actions;
+        Action[] actions;
         uint256 allowFailureMap;
+        uint256 minApprovalPower;
+        TargetConfig targetConfig; // added in v1.3
     }
 
     /// @notice A container for the proposal parameters at the time of proposal creation.
@@ -211,19 +218,31 @@ abstract contract MajorityVotingBase is
             this.totalVotingPower.selector ^
             this.getProposal.selector ^
             this.updateVotingSettings.selector ^
-            this.createProposal.selector;
+            this.updateMinApprovals.selector ^
+            bytes4(
+                keccak256(
+                    "createProposal(bytes,(address,uint256,bytes)[],uint256,uint64,uint64,uint8,bool)"
+                )
+            );
 
     /// @notice The ID of the permission required to call the `updateVotingSettings` function.
     bytes32 public constant UPDATE_VOTING_SETTINGS_PERMISSION_ID =
         keccak256("UPDATE_VOTING_SETTINGS_PERMISSION");
 
+    /// @notice The ID of the permission required to call the `addAddresses` and `removeAddresses` functions.
+    bytes32 public constant CREATE_PROPOSAL_PERMISSION_ID = keccak256("CREATE_PROPOSAL_PERMISSION");
+
     /// @notice A mapping between proposal IDs and proposal information.
     // solhint-disable-next-line named-parameters-mapping
     mapping(uint256 => Proposal) internal proposals;
 
     /// @notice The struct storing the voting settings.
     VotingSettings private votingSettings;
 
+    /// @notice The minimal ratio of yes votes needed for a proposal succeed.
+    /// @dev is not on the VotingSettings for compatibility reasons.
+    uint256 private minApprovals; // added in v1.3
+
     /// @notice Thrown if a date is out of bounds.
     /// @param limit The limit value.
     /// @param actual The actual value.
@@ -252,6 +271,10 @@ abstract contract MajorityVotingBase is
     /// @param proposalId The ID of the proposal.
     error ProposalExecutionForbidden(uint256 proposalId);
 
+    /// @notice Thrown if the proposal with same actions and metadata already exists.
+    /// @param proposalId The id of the proposal.
+    error ProposalAlreadyExists(uint256 proposalId);
+
     /// @notice Emitted when the voting settings are updated.
     /// @param votingMode A parameter to select the vote mode.
     /// @param supportThreshold The support threshold value.
@@ -266,17 +289,27 @@ abstract contract MajorityVotingBase is
         uint256 minProposerVotingPower
     );
 
+    /// @notice Emitted when the min approval value is updated.
+    /// @param minApprovals The minimum amount of yes votes needed for a proposal succeed.
+    event VotingMinApprovalUpdated(uint256 minApprovals);
+
     /// @notice Initializes the component to be used by inheriting contracts.
     /// @dev This method is required to support [ERC-1822](https://eips.ethereum.org/EIPS/eip-1822).
     /// @param _dao The IDAO interface of the associated DAO.
     /// @param _votingSettings The voting settings.
     // solhint-disable-next-line func-name-mixedcase
     function __MajorityVotingBase_init(
         IDAO _dao,
-        VotingSettings calldata _votingSettings
+        VotingSettings calldata _votingSettings,
+        TargetConfig calldata _targetConfig,
+        uint256 _minApprovals,
+        bytes calldata _pluginMetadata
     ) internal onlyInitializing {
         __PluginUUPSUpgradeable_init(_dao);
         _updateVotingSettings(_votingSettings);
+        _updateMinApprovals(_minApprovals);
+        _setTargetConfig(_targetConfig);
+        _setMetadata(_pluginMetadata);
     }
 
     /// @notice Checks if this or the parent contract supports an interface by its ID.
@@ -288,12 +321,25 @@ abstract contract MajorityVotingBase is
         public
         view
         virtual
-        override(ERC165Upgradeable, PluginUUPSUpgradeable, ProposalUpgradeable)
+        override(
+            ERC165Upgradeable,
+            MetadataExtensionUpgradeable,
+            PluginUUPSUpgradeable,
+            ProposalUpgradeable
+        )
         returns (bool)
     {
+        // In addition to the current IMajorityVoting interface, also support previous version
+        // that did not include the `isMinApprovalReached` and `minApproval` functions, same
+        // happens with MAJORITY_VOTING_BASE_INTERFACE which did not include `updateMinApprovals`.
         return
             _interfaceId == MAJORITY_VOTING_BASE_INTERFACE_ID ||
+            _interfaceId == MAJORITY_VOTING_BASE_INTERFACE_ID ^ this.updateMinApprovals.selector ||
             _interfaceId == type(IMajorityVoting).interfaceId ||
+            _interfaceId ==
+            type(IMajorityVoting).interfaceId ^
+                this.isMinApprovalReached.selector ^
+                this.minApproval.selector ||
             super.supportsInterface(_interfaceId);
     }
 
@@ -341,7 +387,9 @@ abstract contract MajorityVotingBase is
     }
 
     /// @inheritdoc IMajorityVoting
-    function canExecute(uint256 _proposalId) public view virtual returns (bool) {
+    function canExecute(
+        uint256 _proposalId
+    ) public view virtual override(IMajorityVoting, IProposal) returns (bool) {
         return _canExecute(_proposalId);
     }
 
@@ -386,6 +434,16 @@ abstract contract MajorityVotingBase is
             proposal_.parameters.minVotingPower;
     }
 
+    /// @inheritdoc IMajorityVoting
+    function isMinApprovalReached(uint256 _proposalId) public view virtual returns (bool) {
+        return proposals[_proposalId].tally.yes >= proposals[_proposalId].minApprovalPower;
+    }
+
+    /// @inheritdoc IMajorityVoting
+    function minApproval() public view virtual returns (uint256) {
+        return minApprovals;
+    }
+
     /// @inheritdoc IMajorityVoting
     function supportThreshold() public view virtual returns (uint32) {
         return votingSettings.supportThreshold;
@@ -438,7 +496,7 @@ abstract contract MajorityVotingBase is
             bool executed,
             ProposalParameters memory parameters,
             Tally memory tally,
-            IDAO.Action[] memory actions,
+            Action[] memory actions,
             uint256 allowFailureMap
         )
     {
@@ -460,6 +518,14 @@ abstract contract MajorityVotingBase is
         _updateVotingSettings(_votingSettings);
     }
 
+    /// @notice Updates the minimal approval value.
+    /// @param _minApprovals The new minimal approval value.
+    function updateMinApprovals(
+        uint256 _minApprovals
+    ) external virtual auth(UPDATE_VOTING_SETTINGS_PERMISSION_ID) {
+        _updateMinApprovals(_minApprovals);
+    }
+
     /// @notice Creates a new majority voting proposal.
     /// @param _metadata The metadata of the proposal.
     /// @param _actions The actions that will be executed after the proposal passes.
@@ -477,7 +543,7 @@ abstract contract MajorityVotingBase is
     /// @return proposalId The ID of the proposal.
     function createProposal(
         bytes calldata _metadata,
-        IDAO.Action[] calldata _actions,
+        Action[] calldata _actions,
         uint256 _allowFailureMap,
         uint64 _startDate,
         uint64 _endDate,
@@ -500,14 +566,19 @@ abstract contract MajorityVotingBase is
     /// @notice Internal function to execute a vote. It assumes the queried proposal exists.
     /// @param _proposalId The ID of the proposal.
     function _execute(uint256 _proposalId) internal virtual {
-        proposals[_proposalId].executed = true;
+        Proposal storage proposal_ = proposals[_proposalId];
+
+        proposal_.executed = true;
 
-        _executeProposal(
-            dao(),
-            _proposalId,
-            proposals[_proposalId].actions,
-            proposals[_proposalId].allowFailureMap
+        _execute(
+            proposal_.targetConfig.target,
+            bytes32(_proposalId),
+            proposal_.actions,
+            proposal_.allowFailureMap,
+            proposal_.targetConfig.operation
         );
+
+        emit ProposalExecuted(_proposalId);
     }
 
     /// @notice Internal function to check if a voter can vote. It assumes the queried proposal exists.
@@ -550,6 +621,9 @@ abstract contract MajorityVotingBase is
         if (!isMinParticipationReached(_proposalId)) {
             return false;
         }
+        if (!isMinApprovalReached(_proposalId)) {
+            return false;
+        }
 
         return true;
     }
@@ -570,7 +644,7 @@ abstract contract MajorityVotingBase is
     /// @param _votingSettings The voting settings to be validated and updated.
     function _updateVotingSettings(VotingSettings calldata _votingSettings) internal virtual {
         // Require the support threshold value to be in the interval [0, 10^6-1],
-        // because `>` comparision is used in the support criterion and >100% could never be reached.
+        // because `>` comparison is used in the support criterion and >100% could never be reached.
         if (_votingSettings.supportThreshold > RATIO_BASE - 1) {
             revert RatioOutOfBounds({
                 limit: RATIO_BASE - 1,
@@ -579,7 +653,7 @@ abstract contract MajorityVotingBase is
         }
 
         // Require the minimum participation value to be in the interval [0, 10^6],
-        // because `>=` comparision is used in the participation criterion.
+        // because `>=` comparison is used in the participation criterion.
         if (_votingSettings.minParticipation > RATIO_BASE) {
             revert RatioOutOfBounds({limit: RATIO_BASE, actual: _votingSettings.minParticipation});
         }
@@ -603,6 +677,19 @@ abstract contract MajorityVotingBase is
         });
     }
 
+    /// @notice Internal function to update minimal approval value.
+    /// @param _minApprovals The new minimal approval value.
+    function _updateMinApprovals(uint256 _minApprovals) internal virtual {
+        // Require the minimum approval value to be in the interval [0, 10^6],
+        // because `>=` comparison is used in the participation criterion.
+        if (_minApprovals > RATIO_BASE) {
+            revert RatioOutOfBounds({limit: RATIO_BASE, actual: _minApprovals});
+        }
+
+        minApprovals = _minApprovals;
+        emit VotingMinApprovalUpdated(_minApprovals);
+    }
+
     /// @notice Validates and returns the proposal vote dates.
     /// @param _start The start date of the proposal vote.
     /// If 0, the current timestamp is used and the vote starts immediately.
@@ -644,5 +731,5 @@ abstract contract MajorityVotingBase is
     /// new variables without shifting down storage in the inheritance chain
     /// (see [OpenZeppelin's guide about storage gaps]
     /// (https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps)).
-    uint256[47] private __gap;
+    uint256[46] private __gap;
 }