@gnosis-guild/zodiac 4.0.3

package/contracts/core/Modifier.sol

@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+import {Enum} from "@gnosis.pm/safe-contracts/contracts/common/Enum.sol";
+import {ExecutionTracker} from "../signature/ExecutionTracker.sol";
+import {IAvatar} from "../interfaces/IAvatar.sol";
+import {Module} from "./Module.sol";
+import {SignatureChecker} from "../signature/SignatureChecker.sol";
+
+/// @title Modifier Interface - A contract that sits between a Module and an Avatar and enforce some additional logic.
+abstract contract Modifier is
+  Module,
+  ExecutionTracker,
+  SignatureChecker,
+  IAvatar
+{
+  address internal constant SENTINEL_MODULES = address(0x1);
+  /// Mapping of modules.
+  mapping(address => address) internal modules;
+
+  /// `sender` is not an authorized module.
+  /// @param sender The address of the sender.
+  error NotAuthorized(address sender);
+
+  /// `module` is invalid.
+  error InvalidModule(address module);
+
+  /// `pageSize` is invalid.
+  error InvalidPageSize();
+
+  /// `module` is already disabled.
+  error AlreadyDisabledModule(address module);
+
+  /// `module` is already enabled.
+  error AlreadyEnabledModule(address module);
+
+  /// @dev `setModules()` was already called.
+  error SetupModulesAlreadyCalled();
+
+  /*
+    --------------------------------------------------
+    You must override both of the following virtual functions,
+    execTransactionFromModule() and execTransactionFromModuleReturnData().
+    It is recommended that implementations of both functions make use the 
+    onlyModule modifier.
+    */
+
+  /// @dev Passes a transaction to the modifier.
+  /// @notice Can only be called by enabled modules.
+  /// @param to Destination address of module transaction.
+  /// @param value Ether value of module transaction.
+  /// @param data Data payload of module transaction.
+  /// @param operation Operation type of module transaction.
+  function execTransactionFromModule(
+    address to,
+    uint256 value,
+    bytes calldata data,
+    Enum.Operation operation
+  ) public virtual returns (bool success);
+
+  /// @dev Passes a transaction to the modifier, expects return data.
+  /// @notice Can only be called by enabled modules.
+  /// @param to Destination address of module transaction.
+  /// @param value Ether value of module transaction.
+  /// @param data Data payload of module transaction.
+  /// @param operation Operation type of module transaction.
+  function execTransactionFromModuleReturnData(
+    address to,
+    uint256 value,
+    bytes calldata data,
+    Enum.Operation operation
+  ) public virtual returns (bool success, bytes memory returnData);
+
+  /*
+    --------------------------------------------------
+    */
+
+  modifier moduleOnly() {
+    if (modules[msg.sender] == address(0)) {
+      (bytes32 hash, address signer) = moduleTxSignedBy();
+
+      // is the signer a module?
+      if (modules[signer] == address(0)) {
+        revert NotAuthorized(msg.sender);
+      }
+
+      // is the provided signature fresh?
+      if (consumed[signer][hash]) {
+        revert HashAlreadyConsumed(hash);
+      }
+
+      consumed[signer][hash] = true;
+      emit HashExecuted(hash);
+    }
+
+    _;
+  }
+
+  function sentOrSignedByModule() internal view returns (address) {
+    if (modules[msg.sender] != address(0)) {
+      return msg.sender;
+    }
+
+    (, address signer) = moduleTxSignedBy();
+    if (modules[signer] != address(0)) {
+      return signer;
+    }
+
+    return address(0);
+  }
+
+  /// @dev Disables a module on the modifier.
+  /// @notice This can only be called by the owner.
+  /// @param prevModule Module that pointed to the module to be removed in the linked list.
+  /// @param module Module to be removed.
+  function disableModule(
+    address prevModule,
+    address module
+  ) public override onlyOwner {
+    if (module == address(0) || module == SENTINEL_MODULES)
+      revert InvalidModule(module);
+    if (modules[prevModule] != module) revert AlreadyDisabledModule(module);
+    modules[prevModule] = modules[module];
+    modules[module] = address(0);
+    emit DisabledModule(module);
+  }
+
+  /// @dev Enables a module that can add transactions to the queue
+  /// @param module Address of the module to be enabled
+  /// @notice This can only be called by the owner
+  function enableModule(address module) public override onlyOwner {
+    if (module == address(0) || module == SENTINEL_MODULES)
+      revert InvalidModule(module);
+    if (modules[module] != address(0)) revert AlreadyEnabledModule(module);
+    modules[module] = modules[SENTINEL_MODULES];
+    modules[SENTINEL_MODULES] = module;
+    emit EnabledModule(module);
+  }
+
+  /// @dev Returns if an module is enabled
+  /// @return True if the module is enabled
+  function isModuleEnabled(
+    address _module
+  ) public view override returns (bool) {
+    return SENTINEL_MODULES != _module && modules[_module] != address(0);
+  }
+
+  /// @dev Returns array of modules.
+  ///      If all entries fit into a single page, the next pointer will be 0x1.
+  ///      If another page is present, next will be the last element of the returned array.
+  /// @param start Start of the page. Has to be a module or start pointer (0x1 address)
+  /// @param pageSize Maximum number of modules that should be returned. Has to be > 0
+  /// @return array Array of modules.
+  /// @return next Start of the next page.
+  function getModulesPaginated(
+    address start,
+    uint256 pageSize
+  ) external view override returns (address[] memory array, address next) {
+    if (start != SENTINEL_MODULES && !isModuleEnabled(start)) {
+      revert InvalidModule(start);
+    }
+    if (pageSize == 0) {
+      revert InvalidPageSize();
+    }
+
+    // Init array with max page size
+    array = new address[](pageSize);
+
+    // Populate return array
+    uint256 moduleCount = 0;
+    next = modules[start];
+    while (
+      next != address(0) && next != SENTINEL_MODULES && moduleCount < pageSize
+    ) {
+      array[moduleCount] = next;
+      next = modules[next];
+      moduleCount++;
+    }
+
+    // Because of the argument validation we can assume that
+    // the `currentModule` will always be either a module address
+    // or sentinel address (aka the end). If we haven't reached the end
+    // inside the loop, we need to set the next pointer to the last element
+    // because it skipped over to the next module which is neither included
+    // in the current page nor won't be included in the next one
+    // if you pass it as a start.
+    if (next != SENTINEL_MODULES) {
+      next = array[moduleCount - 1];
+    }
+    // Set correct size of returned array
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      mstore(array, moduleCount)
+    }
+  }
+
+  /// @dev Initializes the modules linked list.
+  /// @notice Should be called as part of the `setUp` / initializing function and can only be called once.
+  function setupModules() internal {
+    if (modules[SENTINEL_MODULES] != address(0))
+      revert SetupModulesAlreadyCalled();
+    modules[SENTINEL_MODULES] = SENTINEL_MODULES;
+  }
+}

package/contracts/core/Module.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+import {Enum} from "@gnosis.pm/safe-contracts/contracts/common/Enum.sol";
+
+import {FactoryFriendly} from "../factory/FactoryFriendly.sol";
+import {IAvatar} from "../interfaces/IAvatar.sol";
+
+/// @title Module Interface - A contract that can pass messages to a Module Manager contract if enabled by that contract.
+abstract contract Module is FactoryFriendly {
+  /// @dev Address that will ultimately execute function calls.
+  address public avatar;
+  /// @dev Address that this module will pass transactions to.
+  address public target;
+
+  /// @dev Emitted each time the avatar is set.
+  event AvatarSet(address indexed previousAvatar, address indexed newAvatar);
+  /// @dev Emitted each time the Target is set.
+  event TargetSet(address indexed previousTarget, address indexed newTarget);
+
+  /// @dev Sets the avatar to a new avatar (`newAvatar`).
+  /// @notice Can only be called by the current owner.
+  function setAvatar(address _avatar) public onlyOwner {
+    address previousAvatar = avatar;
+    avatar = _avatar;
+    emit AvatarSet(previousAvatar, _avatar);
+  }
+
+  /// @dev Sets the target to a new target (`newTarget`).
+  /// @notice Can only be called by the current owner.
+  function setTarget(address _target) public onlyOwner {
+    address previousTarget = target;
+    target = _target;
+    emit TargetSet(previousTarget, _target);
+  }
+
+  /// @dev Passes a transaction to be executed by the avatar.
+  /// @notice Can only be called by this contract.
+  /// @param to Destination address of module transaction.
+  /// @param value Ether value of module transaction.
+  /// @param data Data payload of module transaction.
+  /// @param operation Operation type of module transaction: 0 == call, 1 == delegate call.
+  function exec(
+    address to,
+    uint256 value,
+    bytes memory data,
+    Enum.Operation operation
+  ) internal virtual returns (bool success) {
+    return
+      IAvatar(target).execTransactionFromModule(to, value, data, operation);
+  }
+
+  /// @dev Passes a transaction to be executed by the target and returns data.
+  /// @notice Can only be called by this contract.
+  /// @param to Destination address of module transaction.
+  /// @param value Ether value of module transaction.
+  /// @param data Data payload of module transaction.
+  /// @param operation Operation type of module transaction: 0 == call, 1 == delegate call.
+  function execAndReturnData(
+    address to,
+    uint256 value,
+    bytes memory data,
+    Enum.Operation operation
+  ) internal virtual returns (bool success, bytes memory returnData) {
+    return
+      IAvatar(target).execTransactionFromModuleReturnData(
+        to,
+        value,
+        data,
+        operation
+      );
+  }
+}

package/contracts/factory/FactoryFriendly.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+
+/// @title Zodiac FactoryFriendly - A contract that allows other contracts to be initializable and pass bytes as arguments to define contract state
+pragma solidity >=0.7.0 <0.9.0;
+
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+abstract contract FactoryFriendly is OwnableUpgradeable {
+  function setUp(bytes memory initializeParams) public virtual;
+}

package/contracts/factory/ModuleProxyFactory.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.8.0;
+
+contract ModuleProxyFactory {
+  event ModuleProxyCreation(address indexed proxy, address indexed masterCopy);
+
+  /// `target` can not be zero.
+  error ZeroAddress(address target);
+
+  /// `target` has no code deployed.
+  error TargetHasNoCode(address target);
+
+  /// `address_` is already taken.
+  error TakenAddress(address address_);
+
+  /// @notice Initialization failed.
+  error FailedInitialization();
+
+  function createProxy(
+    address target,
+    bytes32 salt
+  ) internal returns (address result) {
+    if (address(target) == address(0)) revert ZeroAddress(target);
+    if (address(target).code.length == 0) revert TargetHasNoCode(target);
+    bytes memory deployment = abi.encodePacked(
+      hex"602d8060093d393df3363d3d373d3d3d363d73",
+      target,
+      hex"5af43d82803e903d91602b57fd5bf3"
+    );
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      result := create2(0, add(deployment, 0x20), mload(deployment), salt)
+    }
+    if (result == address(0)) revert TakenAddress(result);
+  }
+
+  function deployModule(
+    address masterCopy,
+    bytes memory initializer,
+    uint256 saltNonce
+  ) public returns (address proxy) {
+    proxy = createProxy(
+      masterCopy,
+      keccak256(abi.encodePacked(keccak256(initializer), saltNonce))
+    );
+    (bool success, ) = proxy.call(initializer);
+    if (!success) revert FailedInitialization();
+
+    emit ModuleProxyCreation(proxy, masterCopy);
+  }
+}

package/contracts/guard/BaseGuard.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+import {Enum} from "@gnosis.pm/safe-contracts/contracts/common/Enum.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {IGuard} from "../interfaces/IGuard.sol";
+
+abstract contract BaseGuard is IERC165 {
+  function supportsInterface(
+    bytes4 interfaceId
+  ) external pure override returns (bool) {
+    return
+      interfaceId == type(IGuard).interfaceId || // 0xe6d7a83a
+      interfaceId == type(IERC165).interfaceId; // 0x01ffc9a7
+  }
+
+  /// @dev Module transactions only use the first four parameters: to, value, data, and operation.
+  /// Module.sol hardcodes the remaining parameters as 0 since they are not used for module transactions.
+  /// @notice This interface is used to maintain compatibilty with Gnosis Safe transaction guards.
+  function checkTransaction(
+    address to,
+    uint256 value,
+    bytes memory data,
+    Enum.Operation operation,
+    uint256 safeTxGas,
+    uint256 baseGas,
+    uint256 gasPrice,
+    address gasToken,
+    address payable refundReceiver,
+    bytes memory signatures,
+    address msgSender
+  ) external virtual;
+
+  function checkAfterExecution(bytes32 txHash, bool success) external virtual;
+}

package/contracts/guard/Guardable.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+import {BaseGuard} from "../guard/BaseGuard.sol";
+import {IGuard} from "../interfaces/IGuard.sol";
+
+/// @title Guardable - A contract that manages fallback calls made to this contract
+contract Guardable is OwnableUpgradeable {
+  address public guard;
+
+  event ChangedGuard(address guard);
+
+  /// `guard_` does not implement IERC165.
+  error NotIERC165Compliant(address guard_);
+
+  /// @dev Set a guard that checks transactions before execution.
+  /// @param _guard The address of the guard to be used or the 0 address to disable the guard.
+  function setGuard(address _guard) external onlyOwner {
+    if (_guard != address(0)) {
+      if (!BaseGuard(_guard).supportsInterface(type(IGuard).interfaceId))
+        revert NotIERC165Compliant(_guard);
+    }
+    guard = _guard;
+    emit ChangedGuard(guard);
+  }
+
+  function getGuard() external view returns (address _guard) {
+    return guard;
+  }
+}

package/contracts/interfaces/IAvatar.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+
+/// @title Zodiac Avatar - A contract that manages modules that can execute transactions via this contract.
+pragma solidity >=0.7.0 <0.9.0;
+
+import {Enum} from "@gnosis.pm/safe-contracts/contracts/common/Enum.sol";
+
+interface IAvatar {
+  event EnabledModule(address module);
+  event DisabledModule(address module);
+  event ExecutionFromModuleSuccess(address indexed module);
+  event ExecutionFromModuleFailure(address indexed module);
+
+  /// @dev Enables a module on the avatar.
+  /// @notice Can only be called by the avatar.
+  /// @notice Modules should be stored as a linked list.
+  /// @notice Must emit EnabledModule(address module) if successful.
+  /// @param module Module to be enabled.
+  function enableModule(address module) external;
+
+  /// @dev Disables a module on the avatar.
+  /// @notice Can only be called by the avatar.
+  /// @notice Must emit DisabledModule(address module) if successful.
+  /// @param prevModule Address that pointed to the module to be removed in the linked list
+  /// @param module Module to be removed.
+  function disableModule(address prevModule, address module) external;
+
+  /// @dev Allows a Module to execute a transaction.
+  /// @notice Can only be called by an enabled module.
+  /// @notice Must emit ExecutionFromModuleSuccess(address module) if successful.
+  /// @notice Must emit ExecutionFromModuleFailure(address module) if unsuccessful.
+  /// @param to Destination address of module transaction.
+  /// @param value Ether value of module transaction.
+  /// @param data Data payload of module transaction.
+  /// @param operation Operation type of module transaction: 0 == call, 1 == delegate call.
+  function execTransactionFromModule(
+    address to,
+    uint256 value,
+    bytes memory data,
+    Enum.Operation operation
+  ) external returns (bool success);
+
+  /// @dev Allows a Module to execute a transaction and return data
+  /// @notice Can only be called by an enabled module.
+  /// @notice Must emit ExecutionFromModuleSuccess(address module) if successful.
+  /// @notice Must emit ExecutionFromModuleFailure(address module) if unsuccessful.
+  /// @param to Destination address of module transaction.
+  /// @param value Ether value of module transaction.
+  /// @param data Data payload of module transaction.
+  /// @param operation Operation type of module transaction: 0 == call, 1 == delegate call.
+  function execTransactionFromModuleReturnData(
+    address to,
+    uint256 value,
+    bytes memory data,
+    Enum.Operation operation
+  ) external returns (bool success, bytes memory returnData);
+
+  /// @dev Returns if an module is enabled
+  /// @return True if the module is enabled
+  function isModuleEnabled(address module) external view returns (bool);
+
+  /// @dev Returns array of modules.
+  /// @param start Start of the page.
+  /// @param pageSize Maximum number of modules that should be returned.
+  /// @return array Array of modules.
+  /// @return next Start of the next page.
+  function getModulesPaginated(
+    address start,
+    uint256 pageSize
+  ) external view returns (address[] memory array, address next);
+}

package/contracts/interfaces/IGuard.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+import {Enum} from "@gnosis.pm/safe-contracts/contracts/common/Enum.sol";
+
+interface IGuard {
+  function checkTransaction(
+    address to,
+    uint256 value,
+    bytes memory data,
+    Enum.Operation operation,
+    uint256 safeTxGas,
+    uint256 baseGas,
+    uint256 gasPrice,
+    address gasToken,
+    address payable refundReceiver,
+    bytes memory signatures,
+    address msgSender
+  ) external;
+
+  function checkAfterExecution(bytes32 txHash, bool success) external;
+}

package/contracts/signature/ExecutionTracker.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.8.0 <0.9.0;
+
+/// @title ExecutionTracker - A contract that keeps track of executed and invalidated hashes
+contract ExecutionTracker {
+  error HashAlreadyConsumed(bytes32);
+
+  event HashExecuted(bytes32);
+  event HashInvalidated(bytes32);
+
+  mapping(address => mapping(bytes32 => bool)) public consumed;
+
+  function invalidate(bytes32 hash) external {
+    consumed[msg.sender][hash] = true;
+    emit HashInvalidated(hash);
+  }
+}

package/contracts/signature/IERC1271.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+/* solhint-disable one-contract-per-file */
+pragma solidity >=0.7.0 <0.9.0;
+
+interface IERC1271 {
+  /**
+   * @notice EIP1271 method to validate a signature.
+   * @param hash Hash of the data signed on the behalf of address(this).
+   * @param signature Signature byte array associated with _data.
+   *
+   * MUST return the bytes4 magic value 0x1626ba7e when function passes.
+   * MUST NOT modify state (using STATICCALL for solc < 0.5, view modifier for solc > 0.5)
+   * MUST allow external calls
+   */
+  function isValidSignature(
+    bytes32 hash,
+    bytes memory signature
+  ) external view returns (bytes4);
+}