Add ERC7579 Validators

.changeset/solid-squids-cough.md

@@ -0,0 +1,5 @@
+---
+'openzeppelin-solidity': minor
+---
+
+`ERC7579Signature`: Add implementation of `ERC7579Validator` that enables ERC-7579 accounts to integrate with address-less cryptographic keys and account signatures through ERC-7913 signature verification.

.changeset/yummy-ideas-stay.md

@@ -0,0 +1,5 @@
+---
+'openzeppelin-solidity': minor
+---
+
+`ERC7579Validator`: Add abstract validator module for ERC-7579 accounts that provides base implementation for signature validation.

contracts/account/README.adoc

@@ -7,6 +7,8 @@ This directory includes contracts to build accounts for ERC-4337. These include:
  * {Account}: An ERC-4337 smart account implementation that includes the core logic to process user operations.
  * {AccountERC7579}: An extension of `Account` that implements support for ERC-7579 modules.
  * {AccountERC7579Hooked}: An extension of `AccountERC7579` with support for a single hook module (type 4).
+ * {ERC7579Validator}: Abstract validator module for ERC-7579 accounts that provides base implementation for signature validation.
+ * {ERC7579Signature}: Implementation of {ERC7579Validator} using ERC-7913 signature verification for address-less cryptographic keys and account signatures.
  * {ERC7821}: Minimal batch executor implementation contracts. Useful to enable easy batch execution for smart contracts.
  * {ERC4337Utils}: Utility functions for working with ERC-4337 user operations.
  * {ERC7579Utils}: Utility functions for working with ERC-7579 modules and account modularity.
@@ -23,6 +25,12 @@ This directory includes contracts to build accounts for ERC-4337. These include:
 
 {{ERC7821}}
 
+=== Validators
+
+{{ERC7579Validator}}
+
+{{ERC7579Signature}}
+
 == Utilities
 
 {{ERC4337Utils}}

contracts/account/modules/ERC7579Signature.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.27;
+
+import {IERC7579Module} from "../../interfaces/draft-IERC7579.sol";
+import {SignatureChecker} from "../../utils/cryptography/SignatureChecker.sol";
+import {ERC7579Validator} from "./ERC7579Validator.sol";
+
+/**
+ * @dev Implementation of {ERC7579Validator} module using ERC-7913 signature verification.
+ *
+ * This validator allows ERC-7579 accounts to integrate with address-less cryptographic keys
+ * and account signatures through the ERC-7913 signature verification system. Each account
+ * can store its own ERC-7913 formatted signer (a concatenation of a verifier address and a
+ * key: `verifier || key`).
+ *
+ * This enables accounts to use signature schemes without requiring each key to have its own
+ * Ethereum address.A smart account with this module installed can keep an emergency key as a
+ * backup.
+ */
+contract ERC7579Signature is ERC7579Validator {
+    mapping(address account => bytes signer) private _signers;
+
+    /// @dev Emitted when the signer is set.
+    event ERC7579SignatureSignerSet(address indexed account, bytes signer);
+
+    /// @dev Thrown when the signer length is less than 20 bytes.
+    error ERC7579SignatureInvalidSignerLength();
+
+    /// @dev Return the ERC-7913 signer (i.e. `verifier || key`).
+    function signer(address account) public view virtual returns (bytes memory) {
+        return _signers[account];
+    }
+
+    /**
+     * @dev See {IERC7579Module-onInstall}.
+     *
+     * NOTE: An account can only call onInstall once. If called directly by the account,
+     * the signer will be set to the provided data. Future installations will behave as a no-op.
+     */
+    function onInstall(bytes calldata data) public virtual {
+        if (signer(msg.sender).length == 0) {
+            setSigner(data);
+        }
+    }
+
+    /**
+     * @dev See {IERC7579Module-onUninstall}.
+     *
+     * WARNING: The signer's key will be removed if the account calls this function, potentially
+     * making the account unusable. As an account operator, make sure to uninstall to a predefined path
+     * in your account that properly handles side effects of uninstallation.  See {AccountERC7579-uninstallModule}.
+     */
+    function onUninstall(bytes calldata) public virtual {
+        _setSigner(msg.sender, "");
+    }
+
+    /// @dev Sets the ERC-7913 signer (i.e. `verifier || key`) for the calling account.
+    function setSigner(bytes memory signer_) public virtual {
+        require(signer_.length >= 20, ERC7579SignatureInvalidSignerLength());
+        _setSigner(msg.sender, signer_);
+    }
+
+    /// @dev Internal version of {setSigner} that takes an `account` as argument without validating `signer_`.
+    function _setSigner(address account, bytes memory signer_) internal virtual {
+        _signers[account] = signer_;
+        emit ERC7579SignatureSignerSet(account, signer_);
+    }
+
+    /**
+     * @dev See {ERC7579Validator-_rawERC7579Validation}.
+     *
+     * Validates a `signature` using ERC-7913 verification.
+     *
+     * This base implementation ignores the `sender` parameter and validates using
+     * the account's stored signer. Derived contracts can override this to implement
+     * custom validation logic based on the sender.
+     */
+    function _rawERC7579Validation(
+        address account,
+        bytes32 hash,
+        bytes calldata signature
+    ) internal view virtual override returns (bool) {
+        return SignatureChecker.isValidSignatureNow(signer(account), hash, signature);
+    }
+}

contracts/account/modules/ERC7579Validator.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.27;
+
+import {IERC7579Module, IERC7579Validator, MODULE_TYPE_VALIDATOR} from "../../interfaces/draft-IERC7579.sol";
+import {PackedUserOperation} from "../../interfaces/draft-IERC4337.sol";
+import {ERC4337Utils} from "../../account/utils/draft-ERC4337Utils.sol";
+import {IERC1271} from "../../interfaces/IERC1271.sol";
+
+/**
+ * @dev Abstract validator module for ERC-7579 accounts.
+ *
+ * This contract provides the base implementation for signature validation in ERC-7579 accounts.
+ * Developers must implement the onInstall, onUninstall, and {_rawERC7579Validation}
+ * functions in derived contracts to define the specific signature validation logic.
+ *
+ * Example usage:
+ *
+ * ```solidity
+ * contract MyValidatorModule is ERC7579Validator {
+ *     function onInstall(bytes calldata data) public {
+ *         // Install logic here
+ *     }
+ *
+ *     function onUninstall(bytes calldata data) public {
+ *         // Uninstall logic here
+ *     }
+ *
+ *     function _rawERC7579Validation(
+ *         address account,
+ *         bytes32 hash,
+ *         bytes calldata signature
+ *     ) internal view override returns (bool) {
+ *         // Signature validation logic here
+ *     }
+ * }
+ * ```
+ *
+ * Developers can restrict other operations by using the internal {_rawERC7579Validation}.
+ * Example usage:
+ *
+ * ```solidity
+ * function execute(
+ *     address account,
+ *     Mode mode,
+ *     bytes calldata executionCalldata,
+ *     bytes32 salt,
+ *     bytes calldata signature
+ * ) public virtual {
+ *     require(_rawERC7579Validation(account, hash, signature));
+ *     // ... rest of execute logic
+ * }
+ * ```
+ */
+abstract contract ERC7579Validator is IERC7579Module, IERC7579Validator {
+    /// @inheritdoc IERC7579Module
+    function isModuleType(uint256 moduleTypeId) public pure virtual returns (bool) {
+        return moduleTypeId == MODULE_TYPE_VALIDATOR;
+    }
+
+    /// @inheritdoc IERC7579Validator
+    function validateUserOp(
+        PackedUserOperation calldata userOp,
+        bytes32 userOpHash
+    ) public view virtual returns (uint256) {
+        return
+            _rawERC7579Validation(msg.sender, userOpHash, userOp.signature)
+                ? ERC4337Utils.SIG_VALIDATION_SUCCESS
+                : ERC4337Utils.SIG_VALIDATION_FAILED;
+    }
+
+    /**
+     * @dev See {IERC7579Validator-isValidSignatureWithSender}.
+     *
+     * Ignores the `sender` parameter and validates using {_rawERC7579Validation}.
+     * Consider overriding this function to implement custom validation logic
+     * based on the original sender.
+     */
+    function isValidSignatureWithSender(
+        address /* sender */,
+        bytes32 hash,
+        bytes calldata signature
+    ) public view virtual returns (bytes4) {
+        return
+            _rawERC7579Validation(msg.sender, hash, signature)
+                ? IERC1271.isValidSignature.selector
+                : bytes4(0xffffffff);
+    }
+
+    /**
+     * @dev Validation algorithm.
+     *
+     * WARNING: Validation is a critical security function. Implementations must carefully
+     * handle cryptographic verification to prevent unauthorized access.
+     */
+    function _rawERC7579Validation(
+        address account,
+        bytes32 hash,
+        bytes calldata signature
+    ) internal view virtual returns (bool);
+}

test/account/modules/ERC7579Module.behavior.js

@@ -0,0 +1,70 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { SIG_VALIDATION_SUCCESS, SIG_VALIDATION_FAILURE } = require('../../helpers/erc4337');
+
+function shouldBehaveLikeERC7579Module() {
+  describe('behaves like ERC7579Module', function () {
+    it('identifies its module type correctly', async function () {
+      await expect(this.mock.isModuleType(this.moduleType)).to.eventually.be.true;
+      await expect(this.mock.isModuleType(999)).to.eventually.be.false; // Using random unassigned module type
+    });
+
+    it('handles installation, uninstallation, and re-installation', async function () {
+      await expect(this.mockFromAccount.onInstall(this.installData || '0x')).to.not.be.reverted;
+      await expect(this.mockFromAccount.onUninstall(this.uninstallData || '0x')).to.not.be.reverted;
+      await expect(this.mockFromAccount.onInstall(this.installData || '0x')).to.not.be.reverted;
+    });
+  });
+}
+
+function shouldBehaveLikeERC7579Validator() {
+  describe('behaves like ERC7579Validator', function () {
+    const MAGIC_VALUE = '0x1626ba7e';
+    const INVALID_VALUE = '0xffffffff';
+
+    beforeEach(async function () {
+      await this.mockFromAccount.onInstall(this.installData);
+    });
+
+    describe('validateUserOp', function () {
+      it('returns SIG_VALIDATION_SUCCESS when signature is valid', async function () {
+        const userOp = await this.mockAccount.createUserOp(this.userOp).then(op => this.signUserOp(op));
+        await expect(this.mockFromAccount.validateUserOp(userOp.packed, userOp.hash())).to.eventually.equal(
+          SIG_VALIDATION_SUCCESS,
+        );
+      });
+
+      it('returns SIG_VALIDATION_FAILURE when signature is invalid', async function () {
+        const userOp = await this.mockAccount.createUserOp(this.userOp);
+        userOp.signature = this.invalidSignature || '0x00';
+        await expect(this.mockFromAccount.validateUserOp(userOp.packed, userOp.hash())).to.eventually.equal(
+          SIG_VALIDATION_FAILURE,
+        );
+      });
+    });
+
+    describe('isValidSignatureWithSender', function () {
+      it('returns magic value for valid signature', async function () {
+        const message = 'Hello, world!';
+        const hash = ethers.hashMessage(message);
+        const signature = await this.signer.signMessage(message);
+        await expect(this.mockFromAccount.isValidSignatureWithSender(this.other, hash, signature)).to.eventually.equal(
+          MAGIC_VALUE,
+        );
+      });
+
+      it('returns failure value for invalid signature', async function () {
+        const hash = ethers.hashMessage('Hello, world!');
+        const signature = this.invalidSignature || '0x00';
+        await expect(this.mock.isValidSignatureWithSender(this.other, hash, signature)).to.eventually.equal(
+          INVALID_VALUE,
+        );
+      });
+    });
+  });
+}
+
+module.exports = {
+  shouldBehaveLikeERC7579Module,
+  shouldBehaveLikeERC7579Validator,
+};