@gnosis-guild/zodiac 4.0.3

package/contracts/signature/SignatureChecker.sol

@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.8.0 <0.9.0;
+
+import {IERC1271} from "./IERC1271.sol";
+
+/// @title SignatureChecker - A contract that retrieves and validates signatures appended to transaction calldata.
+/// @dev currently supports eip-712 and eip-1271 signatures
+abstract contract SignatureChecker {
+  /**
+   * @notice Searches for a signature, validates it, and returns the signer's address.
+   * @dev When signature not found or invalid, zero address is returned
+   * @return The address of the signer.
+   */
+  function moduleTxSignedBy() internal view returns (bytes32, address) {
+    bytes calldata data = msg.data;
+
+    /*
+     * The idea is to extend `onlyModule` and provide signature checking
+     * without code changes to inheriting contracts (Modifiers).
+     *
+     * Since it's a generic mechanism, there is no way to conclusively
+     * identify the trailing bytes as a signature. We simply slice those
+     * and recover signer.
+     *
+     * As a result, we impose a minimum calldata length equal to a function
+     * selector plus salt, plus a signature (i.e., 4 + 32 + 65 bytes), any
+     * shorter and calldata it guaranteed to not contain a signature.
+     */
+    if (data.length < 4 + 32 + 65) {
+      return (bytes32(0), address(0));
+    }
+
+    (uint8 v, bytes32 r, bytes32 s) = _splitSignature(data);
+
+    uint256 end = data.length - (32 + 65);
+    bytes32 salt = bytes32(data[end:]);
+
+    /*
+     * When handling contract signatures:
+     *  v - is zero
+     *  r - contains the signer
+     *  s - contains the offset within calldata where the signer specific
+     *      signature is located
+     *
+     * We detect contract signatures by checking:
+     *  1- `v` is zero
+     *  2- `s` points within the buffer, is after selector, is before
+     *      salt and delimits a non-zero length buffer
+     */
+    if (v == 0) {
+      uint256 start = uint256(s);
+      if (start < 4 || start > end) {
+        return (bytes32(0), address(0));
+      }
+      address signer = address(uint160(uint256(r)));
+
+      bytes32 hash = moduleTxHash(data[:start], salt);
+      return
+        _isValidContractSignature(signer, hash, data[start:end])
+          ? (hash, signer)
+          : (bytes32(0), address(0));
+    } else {
+      bytes32 hash = moduleTxHash(data[:end], salt);
+      return (hash, ecrecover(hash, v, r, s));
+    }
+  }
+
+  /**
+   * @notice Hashes the transaction EIP-712 data structure.
+   * @dev The produced hash is intended to be signed.
+   * @param data The current transaction's calldata.
+   * @param salt The salt value.
+   * @return The 32-byte hash that is to be signed.
+   */
+  function moduleTxHash(
+    bytes calldata data,
+    bytes32 salt
+  ) public view returns (bytes32) {
+    bytes32 domainSeparator = keccak256(
+      abi.encode(DOMAIN_SEPARATOR_TYPEHASH, block.chainid, this)
+    );
+    bytes memory moduleTxData = abi.encodePacked(
+      bytes1(0x19),
+      bytes1(0x01),
+      domainSeparator,
+      keccak256(abi.encode(MODULE_TX_TYPEHASH, keccak256(data), salt))
+    );
+    return keccak256(moduleTxData);
+  }
+
+  /**
+   * @dev Extracts signature from calldata, and divides it into `uint8 v, bytes32 r, bytes32 s`.
+   * @param data The current transaction's calldata.
+   * @return v The ECDSA v value
+   * @return r The ECDSA r value
+   * @return s The ECDSA s value
+   */
+  function _splitSignature(
+    bytes calldata data
+  ) private pure returns (uint8 v, bytes32 r, bytes32 s) {
+    v = uint8(bytes1(data[data.length - 1:]));
+    r = bytes32(data[data.length - 65:]);
+    s = bytes32(data[data.length - 33:]);
+  }
+
+  /**
+   * @dev Calls the signer contract, and validates the contract signature.
+   * @param signer The address of the signer contract.
+   * @param hash Hash of the data signed
+   * @param signature The contract signature.
+   * @return result Indicates whether the signature is valid.
+   */
+  function _isValidContractSignature(
+    address signer,
+    bytes32 hash,
+    bytes calldata signature
+  ) internal view returns (bool result) {
+    uint256 size;
+    // eslint-disable-line no-inline-assembly
+    assembly {
+      size := extcodesize(signer)
+    }
+    if (size == 0) {
+      return false;
+    }
+
+    (, bytes memory returnData) = signer.staticcall(
+      abi.encodeWithSelector(
+        IERC1271.isValidSignature.selector,
+        hash,
+        signature
+      )
+    );
+
+    return bytes4(returnData) == EIP1271_MAGIC_VALUE;
+  }
+
+  // keccak256(
+  //     "EIP712Domain(uint256 chainId,address verifyingContract)"
+  // );
+  bytes32 private constant DOMAIN_SEPARATOR_TYPEHASH =
+    0x47e79534a245952e8b16893a336b85a3d9ea9fa8c573f3d803afb92a79469218;
+
+  // keccak256(
+  //     "ModuleTx(bytes data,bytes32 salt)"
+  // );
+  bytes32 private constant MODULE_TX_TYPEHASH =
+    0x2939aeeda3ca260200c9f7b436b19e13207547ccc65cfedc857751c5ea6d91d4;
+
+  // bytes4(keccak256(
+  //     "isValidSignature(bytes32,bytes)"
+  // ));
+  bytes4 private constant EIP1271_MAGIC_VALUE = 0x1626ba7e;
+}

package/contracts/test/TestAvatar.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.8.0;
+
+contract Enum {
+  enum Operation {
+    Call,
+    DelegateCall
+  }
+}
+
+contract TestAvatar {
+  address public module;
+
+  receive() external payable {}
+
+  function enableModule(address _module) external {
+    module = _module;
+  }
+
+  function disableModule(address, address) external {
+    module = address(0);
+  }
+
+  function isModuleEnabled(address _module) external view returns (bool) {
+    if (module == _module) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  function execTransactionFromModule(
+    address payable to,
+    uint256 value,
+    bytes calldata data,
+    uint8 operation
+  ) external returns (bool success) {
+    require(msg.sender == module, "Not authorized");
+    if (operation == 1) (success, ) = to.delegatecall(data);
+    else (success, ) = to.call{value: value}(data);
+  }
+
+  function execTransactionFromModuleReturnData(
+    address payable to,
+    uint256 value,
+    bytes calldata data,
+    uint8 operation
+  ) external returns (bool success, bytes memory returnData) {
+    require(msg.sender == module, "Not authorized");
+    if (operation == 1) (success, ) = to.delegatecall(data);
+    else (success, returnData) = to.call{value: value}(data);
+  }
+
+  function getModulesPaginated(
+    address,
+    uint256 pageSize
+  ) external view returns (address[] memory array, address next) {
+    // Init array with max page size
+    array = new address[](pageSize);
+
+    array[0] = module;
+    next = module;
+  }
+}

package/contracts/test/TestGuard.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {BaseGuard} from "../guard/BaseGuard.sol";
+import {Enum} from "@gnosis.pm/safe-contracts/contracts/common/Enum.sol";
+import {FactoryFriendly} from "../factory/FactoryFriendly.sol";
+import {GuardableModule} from "../core/GuardableModule.sol";
+
+/* solhint-disable */
+
+contract TestGuard is FactoryFriendly, BaseGuard {
+  event PreChecked(address sender);
+  event PostChecked(bool checked);
+
+  address public module;
+
+  constructor(address _module) {
+    bytes memory initParams = abi.encode(_module);
+    setUp(initParams);
+  }
+
+  function setModule(address _module) public {
+    module = _module;
+  }
+
+  function checkTransaction(
+    address to,
+    uint256 value,
+    bytes memory data,
+    Enum.Operation operation,
+    uint256,
+    uint256,
+    uint256,
+    address,
+    address payable,
+    bytes memory,
+    address sender
+  ) public override {
+    require(to != address(0), "Cannot send to zero address");
+    require(value != 1337, "Cannot send 1337");
+    require(bytes3(data) != bytes3(0xbaddad), "Cannot call 0xbaddad");
+    require(operation != Enum.Operation(1), "No delegate calls");
+    emit PreChecked(sender);
+  }
+
+  function checkAfterExecution(bytes32, bool) public override {
+    require(
+      GuardableModule(module).guard() == address(this),
+      "Module cannot remove its own guard."
+    );
+    emit PostChecked(true);
+  }
+
+  function setUp(bytes memory initializeParams) public override initializer {
+    address _module = abi.decode(initializeParams, (address));
+    module = _module;
+  }
+}
+
+contract TestNonCompliantGuard is IERC165 {
+  function supportsInterface(bytes4) external pure returns (bool) {
+    return false;
+  }
+
+  function checkTransaction(
+    address,
+    uint256,
+    bytes memory,
+    Enum.Operation,
+    uint256,
+    uint256,
+    uint256,
+    address,
+    address,
+    bytes memory,
+    address
+  ) public {}
+
+  function checkAfterExecution(bytes32, bool) public {}
+}

package/contracts/test/TestGuardableModifier.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+import "../core/GuardableModifier.sol";
+
+contract TestGuardableModifier is GuardableModifier {
+  event Executed(
+    address to,
+    uint256 value,
+    bytes data,
+    Enum.Operation operation,
+    bool success
+  );
+
+  event ExecutedAndReturnedData(
+    address to,
+    uint256 value,
+    bytes data,
+    Enum.Operation operation,
+    bytes returnData,
+    bool success
+  );
+
+  constructor(address _avatar, address _target) {
+    bytes memory initParams = abi.encode(_avatar, _target);
+    setUp(initParams);
+  }
+
+  /// @dev Passes a transaction to the modifier.
+  /// @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
+  /// @notice Can only be called by enabled modules
+  function execTransactionFromModule(
+    address to,
+    uint256 value,
+    bytes calldata data,
+    Enum.Operation operation
+  ) public override moduleOnly returns (bool success) {
+    success = exec(to, value, data, operation);
+    emit Executed(to, value, data, operation, success);
+  }
+
+  /// @dev Passes a transaction to the modifier, expects return data.
+  /// @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
+  /// @notice Can only be called by enabled modules
+  function execTransactionFromModuleReturnData(
+    address to,
+    uint256 value,
+    bytes calldata data,
+    Enum.Operation operation
+  ) public override moduleOnly returns (bool success, bytes memory returnData) {
+    (success, returnData) = execAndReturnData(to, value, data, operation);
+    emit ExecutedAndReturnedData(
+      to,
+      value,
+      data,
+      operation,
+      returnData,
+      success
+    );
+  }
+
+  function setUp(bytes memory initializeParams) public override initializer {
+    setupModules();
+    __Ownable_init(msg.sender);
+    (address _avatar, address _target) = abi.decode(
+      initializeParams,
+      (address, address)
+    );
+    avatar = _avatar;
+    target = _target;
+  }
+
+  function attemptToSetupModules() public {
+    setupModules();
+  }
+}

package/contracts/test/TestModifier.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+
+/// @title Modifier Interface - A contract that sits between a Module and an Avatar and enforce some additional logic.
+pragma solidity >=0.7.0 <0.9.0;
+
+import "../core/Modifier.sol";
+
+contract TestModifier is Modifier {
+  event Executed(
+    address to,
+    uint256 value,
+    bytes data,
+    Enum.Operation operation,
+    bool success
+  );
+
+  event ExecutedAndReturnedData(
+    address to,
+    uint256 value,
+    bytes data,
+    Enum.Operation operation,
+    bytes returnData,
+    bool success
+  );
+
+  constructor(address _avatar, address _target) {
+    bytes memory initParams = abi.encode(_avatar, _target);
+    setUp(initParams);
+  }
+
+  /// @dev Passes a transaction to the modifier.
+  /// @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
+  /// @notice Can only be called by enabled modules
+  function execTransactionFromModule(
+    address to,
+    uint256 value,
+    bytes calldata data,
+    Enum.Operation operation
+  ) public override moduleOnly returns (bool success) {
+    success = exec(to, value, data, operation);
+    emit Executed(to, value, data, operation, success);
+  }
+
+  /// @dev Passes a transaction to the modifier, expects return data.
+  /// @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
+  /// @notice Can only be called by enabled modules
+  function execTransactionFromModuleReturnData(
+    address to,
+    uint256 value,
+    bytes calldata data,
+    Enum.Operation operation
+  ) public override moduleOnly returns (bool success, bytes memory returnData) {
+    (success, returnData) = execAndReturnData(to, value, data, operation);
+    emit ExecutedAndReturnedData(
+      to,
+      value,
+      data,
+      operation,
+      returnData,
+      success
+    );
+  }
+
+  function setUp(bytes memory initializeParams) public override initializer {
+    (address _avatar, address _target) = abi.decode(
+      initializeParams,
+      (address, address)
+    );
+    setupModules();
+    _transferOwnership(msg.sender);
+    avatar = _avatar;
+    target = _target;
+  }
+
+  function exposeSentOrSignedByModule() external view returns (address) {
+    return sentOrSignedByModule();
+  }
+
+  function attemptToSetupModules() public {
+    setupModules();
+  }
+}

package/contracts/test/TestModule.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+
+/// @title Modifier Interface - A contract that sits between a Module and an Avatar and enforce some additional logic.
+pragma solidity >=0.7.0 <0.9.0;
+
+import "../core/GuardableModule.sol";
+
+contract TestModule is GuardableModule {
+  constructor(address _avatar, address _target) {
+    bytes memory initParams = abi.encode(_avatar, _target);
+    setUp(initParams);
+  }
+
+  event executed(
+    address to,
+    uint256 value,
+    bytes data,
+    Enum.Operation operation,
+    bool success
+  );
+  event executedAndReturnedData(
+    address to,
+    uint256 value,
+    bytes data,
+    Enum.Operation operation,
+    bytes returnData,
+    bool success
+  );
+
+  function executeTransaction(
+    address to,
+    uint256 value,
+    bytes memory data,
+    Enum.Operation operation
+  ) public returns (bool success) {
+    success = exec(to, value, data, operation);
+    emit executed(to, value, data, operation, success);
+  }
+
+  function executeTransactionReturnData(
+    address to,
+    uint256 value,
+    bytes memory data,
+    Enum.Operation operation
+  ) public returns (bool success, bytes memory returnData) {
+    (success, returnData) = execAndReturnData(to, value, data, operation);
+    emit executedAndReturnedData(
+      to,
+      value,
+      data,
+      operation,
+      returnData,
+      success
+    );
+  }
+
+  function setUp(bytes memory initializeParams) public override initializer {
+    __Ownable_init(msg.sender);
+    (address _avatar, address _target) = abi.decode(
+      initializeParams,
+      (address, address)
+    );
+    avatar = _avatar;
+    target = _target;
+  }
+}

package/contracts/test/TestSignature.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.8.0;
+
+import "../signature/SignatureChecker.sol";
+
+contract ContractSignerYes is IERC1271 {
+  function isValidSignature(
+    bytes32,
+    bytes memory
+  ) external pure override returns (bytes4) {
+    return 0x1626ba7e;
+  }
+}
+
+contract ContractSignerNo is IERC1271 {
+  function isValidSignature(
+    bytes32,
+    bytes memory
+  ) external pure override returns (bytes4) {
+    return 0x33333333;
+  }
+}
+
+contract ContractSignerMaybe is IERC1271 {
+  function isValidSignature(
+    bytes32,
+    bytes memory contractSpecificSignature
+  ) external pure override returns (bytes4) {
+    bool isValid = contractSpecificSignature.length == 6 &&
+      bytes6(contractSpecificSignature) == 0x001122334455;
+
+    return isValid ? bytes4(0x1626ba7e) : bytes4(0x33333333);
+  }
+}
+
+contract ContractSignerOnlyEmpty is IERC1271 {
+  function isValidSignature(
+    bytes32,
+    bytes memory contractSpecificSignature
+  ) external pure override returns (bytes4) {
+    bool isValid = contractSpecificSignature.length == 0;
+    return isValid ? bytes4(0x1626ba7e) : bytes4(0x33333333);
+  }
+}
+
+contract ContractSignerFaulty {}
+
+contract ContractSignerReturnSize {
+  function isValidSignature(
+    bytes32,
+    bytes memory
+  ) external pure returns (bytes2) {
+    return 0x1626;
+  }
+}
+
+contract TestSignature is SignatureChecker {
+  event Hello(address signer);
+
+  event Goodbye(address signer);
+
+  function hello() public {
+    (, address signer) = moduleTxSignedBy();
+    emit Hello(signer);
+  }
+
+  function goodbye(uint256, bytes memory) public {
+    (, address signer) = moduleTxSignedBy();
+    emit Goodbye(signer);
+  }
+}