feat: Extended PM with permission owner and delegation capabilities

packages/contracts/deploy/update/to_v1.3.0/90_ManagingDAO.ts

@@ -1,6 +1,9 @@
 import {DAOFactory__factory, DAO__factory} from '../../../typechain';
 import {getContractAddress} from '../../helpers';
-import {IMPLICIT_INITIAL_PROTOCOL_VERSION} from '@aragon/osx-commons-sdk';
+import {
+  getProtocolVersion,
+  IMPLICIT_INITIAL_PROTOCOL_VERSION,
+} from '@aragon/osx-commons-sdk';
 import {DeployFunction} from 'hardhat-deploy/types';
 import {HardhatRuntimeEnvironment} from 'hardhat/types';
 
@@ -24,7 +27,8 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
   const upgradeTX = await managementDAO.populateTransaction.upgradeToAndCall(
     newDaoImplementation,
     managementDAO.interface.encodeFunctionData('initializeFrom', [
-      IMPLICIT_INITIAL_PROTOCOL_VERSION,
+      // Get the managing dao's protocol version from which upgrade will happen.
+      await getProtocolVersion(managementDAO),
       [],
     ])
   );
@@ -38,6 +42,8 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
     value: 0,
     description: `Upgrade the <strong>management DAO</strong> (<code>${managementDAOAddress}</code>) to the new <strong>implementation</strong> (<code>${newDaoImplementation}</code>).`,
   });
+
+  console.log(hre.managementDAOActions);
 };
 export default func;
 func.tags = ['ManagementDAO', 'v1.3.0'];

packages/contracts/hardhat.config.ts

@@ -12,13 +12,16 @@ import '@openzeppelin/hardhat-upgrades';
 import * as dotenv from 'dotenv';
 import 'hardhat-deploy';
 import 'hardhat-gas-reporter';
-import {extendEnvironment, HardhatUserConfig} from 'hardhat/config';
+import {extendEnvironment, HardhatUserConfig, task} from 'hardhat/config';
 import type {NetworkUserConfig} from 'hardhat/types';
 import 'solidity-coverage';
 import 'solidity-docgen';
+import util from 'util';
 
 dotenv.config();
 
+const exec = util.promisify(require('child_process').exec);
+
 const ETH_KEY = process.env.ETH_KEY;
 const accounts = ETH_KEY ? ETH_KEY.split(',') : [];
 
@@ -53,6 +56,15 @@ extendEnvironment(hre => {
   hre.testingFork = testingFork;
 });
 
+// Needed to override and extend in order to make coverage work with typechain
+// Without this, it doesn't generate typechains the way we want with custom scripts.
+task('coverage').setAction(async (args, hre, runSuper) => {
+  await exec('yarn typechain:osx');
+  await exec('yarn typechain:osx-versions');
+
+  await runSuper();
+});
+
 const ENABLE_DEPLOY_TEST = process.env.TEST_UPDATE_DEPLOY_SCRIPT !== undefined;
 
 console.log('Is deploy test is enabled: ', ENABLE_DEPLOY_TEST);

packages/contracts/scripts/generate-typechain-osx.ts

@@ -28,7 +28,12 @@ async function generateTypechain(): Promise<void> {
     }
 
     const dirPath = path.dirname(filePath);
-    if (!excludedDirs.has(dirPath)) {
+
+    // Only arrange the contracts' paths in the current 
+    // directory without previous versions.
+    const containsPrefix = Array.from(excludedDirs).some(prefix => dirPath.startsWith(prefix));
+
+    if (!containsPrefix) {
       jsonFiles.push(filePath);
     }
   });

packages/contracts/src/core/dao/DAO.sol

@@ -18,6 +18,7 @@ import {ProtocolVersion} from "@aragon/osx-commons-contracts/src/utils/versionin
 import {VersionComparisonLib} from "@aragon/osx-commons-contracts/src/utils/versioning/VersionComparisonLib.sol";
 import {hasBit, flipBit} from "@aragon/osx-commons-contracts/src/utils/math/BitMap.sol";
 import {IDAO} from "@aragon/osx-commons-contracts/src/dao/IDAO.sol";
+import {IExecutor, Action} from "@aragon/osx-commons-contracts/src/executors/IExecutor.sol";
 
 import {PermissionManager} from "../permission/PermissionManager.sol";
 import {CallbackHandler} from "../utils/CallbackHandler.sol";
@@ -28,12 +29,14 @@ import {IEIP4824} from "./IEIP4824.sol";
 /// @notice This contract is the entry point to the Aragon DAO framework and provides our users a simple and easy to use public interface.
 /// @dev Public API of the Aragon DAO framework.
 /// @custom:security-contact sirt@aragon.org
+/// @custom:oz-upgrades-unsafe-allow constructor constructor delegatecall
 contract DAO is
     IEIP4824,
     Initializable,
     IERC1271,
     ERC165StorageUpgradeable,
     IDAO,
+    IExecutor,
     UUPSUpgradeable,
     ProtocolVersion,
     PermissionManager,
@@ -60,6 +63,9 @@ contract DAO is
     bytes32 public constant REGISTER_STANDARD_CALLBACK_PERMISSION_ID =
         keccak256("REGISTER_STANDARD_CALLBACK_PERMISSION");
 
+    /// @notice The ID of the permission that allows to withdraw native eth by allowed entities.
+    bytes32 private constant ETH_TRANSFER_PERMISSION_ID = keccak256("");
+
     /// @notice The ID of the permission required to validate [ERC-1271](https://eips.ethereum.org/EIPS/eip-1271) signatures.
     bytes32 public constant VALIDATE_SIGNATURE_PERMISSION_ID =
         keccak256("VALIDATE_SIGNATURE_PERMISSION");
@@ -117,6 +123,9 @@ contract DAO is
     /// @notice Thrown when a function is removed but left to not corrupt the interface ID.
     error FunctionRemoved();
 
+    /// @notice Thrown when initialize is called after it has already been executed.
+    error AlreadyInitialized();
+
     /// @notice Emitted when a new DAO URI is set.
     /// @param daoURI The new URI.
     event NewURI(string daoURI);
@@ -134,8 +143,16 @@ contract DAO is
         _reentrancyStatus = _NOT_ENTERED;
     }
 
+    /// @notice This ensures that the initialize function cannot be called during the upgrade process.
+    modifier onlyCallAtInitialization() {
+        if (_getInitializedVersion() != 0) {
+            revert AlreadyInitialized();
+        }
+
+        _;
+    }
+
     /// @notice Disables the initializers on the implementation contract to prevent it from being left uninitialized.
-    /// @custom:oz-upgrades-unsafe-allow constructor
     constructor() {
         _disableInitializers();
     }
@@ -155,10 +172,14 @@ contract DAO is
         address _initialOwner,
         address _trustedForwarder,
         string calldata daoURI_
-    ) external reinitializer(3) {
+    ) external onlyCallAtInitialization reinitializer(3) {
         _reentrancyStatus = _NOT_ENTERED; // added in v1.3.0
 
+        // In addition to the current interfaceId, also support previous version of the interfaceId.
+        _registerInterface(type(IDAO).interfaceId ^ IExecutor.execute.selector);
+
         _registerInterface(type(IDAO).interfaceId);
+        _registerInterface(type(IExecutor).interfaceId);
         _registerInterface(type(IERC1271).interfaceId);
         _registerInterface(type(IEIP4824).interfaceId);
         _registerInterface(type(IProtocolVersion).interfaceId); // added in v1.3.0
@@ -198,6 +219,9 @@ contract DAO is
                 _who: address(this),
                 _permissionId: keccak256("SET_SIGNATURE_VALIDATOR_PERMISSION")
             });
+
+            _registerInterface(type(IDAO).interfaceId);
+            _registerInterface(type(IExecutor).interfaceId);
         }
     }
 
@@ -246,18 +270,12 @@ contract DAO is
         _setMetadata(_metadata);
     }
 
-    /// @inheritdoc IDAO
+    /// @inheritdoc IExecutor
     function execute(
         bytes32 _callId,
         Action[] calldata _actions,
         uint256 _allowFailureMap
-    )
-        external
-        override
-        nonReentrant
-        auth(EXECUTE_PERMISSION_ID)
-        returns (bytes[] memory execResults, uint256 failureMap)
-    {
+    ) external override nonReentrant returns (bytes[] memory execResults, uint256 failureMap) {
         // Check that the action array length is within bounds.
         if (_actions.length > MAX_ACTIONS) {
             revert TooManyActions();
@@ -268,14 +286,65 @@ contract DAO is
         uint256 gasBefore;
         uint256 gasAfter;
 
+        bool hasExecutePermission = isGranted(
+            address(this),
+            msg.sender,
+            EXECUTE_PERMISSION_ID,
+            msg.data
+        );
+
         for (uint256 i = 0; i < _actions.length; ) {
+            Action calldata action = _actions[i];
+
+            bool isAllowed = hasExecutePermission;
+            bytes32 permissionId = EXECUTE_PERMISSION_ID;
+
+            bytes32 id;
+
+            // If action.data is 0 length, it's native eth transfer
+            // which is checked the same way, though `id` is keccak256('0x').
+            if (action.data.length >= 4) {
+                id = keccak256(action.data[:4]);
+            } else if (action.data.length == 0) {
+                id = ETH_TRANSFER_PERMISSION_ID;
+            }
+
+            (bool created, , ) = getPermissionStatus(action.to, id);
+
+            if (created) {
+                isAllowed = isGranted(action.to, msg.sender, id, action.data);
+                permissionId = id;
+            }
+
+            if (!isAllowed) {
+                revert Unauthorized(action.to, msg.sender, permissionId);
+            }
+
+            bool success;
+            bytes memory data;
+
             gasBefore = gasleft();
 
-            (bool success, bytes memory result) = _actions[i].to.call{value: _actions[i].value}(
-                _actions[i].data
-            );
+            (success, data) = action.to.call{value: action.value}(action.data);
+
             gasAfter = gasleft();
 
+            if (action.to == address(this)) {
+                if (!success) {
+                    bytes4 result;
+
+                    assembly {
+                        result := mload(add(data, 32))
+                    }
+
+                    if (result == Unauthorized.selector || result == UnauthorizedOwner.selector) {
+                        gasBefore = gasleft();
+                        (success, data) = action.to.delegatecall(action.data);
+                        gasAfter = gasleft();
+                    }
+                }
+            }
+
             // Check if failure is allowed
             if (!hasBit(_allowFailureMap, uint8(i))) {
                 // Check if the call failed.
@@ -297,7 +366,7 @@ contract DAO is
                 }
             }
 
-            execResults[i] = result;
+            execResults[i] = data;
 
             unchecked {
                 ++i;