Implement ERC-4337 Account and ERC-7579 modules

contracts/account/AccountBase.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {PackedUserOperation, IAccount, IEntryPoint, IAccountExecute} from "../interfaces/IERC4337.sol";
+import {Address} from "../utils/Address.sol";
+
+/**
+ * @dev A simple ERC4337 account implementation.
+ *
+ * This base implementation only includes the minimal logic to process user operations.
+ * Developers must implement the {_validateUserOp} function to define the account's validation logic.
+ */
+abstract contract AccountBase is IAccount, IAccountExecute {
+    /**
+     * @dev Unauthorized call to the account.
+     */
+    error AccountUnauthorized(address sender);
+
+    /**
+     * @dev Revert if the caller is not the entry point or the account itself.
+     */
+    modifier onlyEntryPointOrSelf() {
+        _checkEntryPointOrSelf();
+        _;
+    }
+
+    /**
+     * @dev Revert if the caller is not the entry point.
+     */
+    modifier onlyEntryPoint() {
+        _checkEntryPoint();
+        _;
+    }
+
+    /**
+     * @dev Canonical entry point for the account that forwards and validates user operations.
+     */
+    function entryPoint() public view virtual returns (IEntryPoint) {
+        return IEntryPoint(0x0000000071727De22E5E9d8BAf0edAc6f37da032);
+    }
+
+    /**
+     * @dev Return the account nonce for the canonical sequence.
+     */
+    function getNonce() public view virtual returns (uint256) {
+        return getNonce(0);
+    }
+
+    /**
+     * @dev Return the account nonce for a given sequence (key).
+     */
+    function getNonce(uint192 key) public view virtual returns (uint256) {
+        return entryPoint().getNonce(address(this), key);
+    }
+
+    /**
+     * @inheritdoc IAccount
+     */
+    function validateUserOp(
+        PackedUserOperation calldata userOp,
+        bytes32 userOpHash,
+        uint256 missingAccountFunds
+    ) public virtual onlyEntryPoint returns (uint256) {
+        uint256 validationData = _validateUserOp(userOp, userOpHash);
+        _payPrefund(missingAccountFunds);
+        return validationData;
+    }
+
+    /**
+     * @inheritdoc IAccountExecute
+     */
+    function executeUserOp(
+        PackedUserOperation calldata userOp,
+        bytes32 /*userOpHash*/
+    ) public virtual onlyEntryPointOrSelf {
+        (address target, uint256 value, bytes memory data) = abi.decode(userOp.callData[4:], (address, uint256, bytes));
+        Address.functionCallWithValue(target, data, value);
+    }
+
+    /**
+     * @dev Validation logic for {validateUserOp}.
+     *
+     * IMPORTANT: Implementing a mechanism to validate user operations is a security-sensitive operation
+     * as it may allow an attacker to bypass the account's security measures. Check out {AccountECDSA},
+     * {AccountP256}, or {AccountRSA} for digital signature validation implementations.
+     */
+    function _validateUserOp(
+        PackedUserOperation calldata userOp,
+        bytes32 userOpHash
+    ) internal virtual returns (uint256 validationData);
+
+    /**
+     * @dev Sends the missing funds for executing the user operation to the {entrypoint}.
+     * The `missingAccountFunds` must be defined by the entrypoint when calling {validateUserOp}.
+     */
+    function _payPrefund(uint256 missingAccountFunds) internal virtual {
+        if (missingAccountFunds > 0) {
+            (bool success, ) = payable(msg.sender).call{value: missingAccountFunds}("");
+            success; // Silence warning. The entrypoint should validate the result.
+        }
+    }
+
+    /**
+     * @dev Ensures the caller is the {entrypoint}.
+     */
+    function _checkEntryPoint() internal view virtual {
+        if (msg.sender != address(entryPoint())) {
+            revert AccountUnauthorized(msg.sender);
+        }
+    }
+
+    /**
+     * @dev Ensures the caller is the {entrypoint} or the account itself.
+     */
+    function _checkEntryPointOrSelf() internal view virtual {
+        if (msg.sender != address(this) && msg.sender != address(entryPoint())) {
+            revert AccountUnauthorized(msg.sender);
+        }
+    }
+
+    /**
+     * @dev Receive Ether.
+     */
+    receive() external payable virtual {}
+}

contracts/account/AccountECDSA.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {PackedUserOperation} from "../interfaces/IERC4337.sol";
+import {AccountBase} from "./AccountBase.sol";
+import {ERC1271TypedSigner} from "../utils/cryptography/ERC1271TypedSigner.sol";
+import {ECDSA} from "../utils/cryptography/ECDSA.sol";
+import {ERC4337Utils} from "./utils/ERC4337Utils.sol";
+import {ERC721Holder} from "../token/ERC721/utils/ERC721Holder.sol";
+import {ERC1155HolderLean, IERC1155Receiver} from "../token/ERC1155/utils/ERC1155HolderLean.sol";
+import {ERC165} from "../utils/introspection/ERC165.sol";
+import {IERC165} from "../utils/introspection/IERC165.sol";
+
+/**
+ * @dev Account implementation using {ECDSA} signatures and {ERC1271TypedSigner} for replay protection.
+ */
+abstract contract AccountECDSA is ERC165, ERC1271TypedSigner, ERC721Holder, ERC1155HolderLean, AccountBase {
+    address private immutable _signer;
+
+    /**
+     * @dev Initializes the account with the address of the native signer.
+     */
+    constructor(address signerAddr) {
+        _signer = signerAddr;
+    }
+
+    /**
+     * @dev Return the account's signer address.
+     */
+    function signer() public view virtual returns (address) {
+        return _signer;
+    }
+
+    /**
+     * @dev Internal version of {validateUserOp} that relies on {_isValidSignature}.
+     */
+    function _validateUserOp(
+        PackedUserOperation calldata userOp,
+        bytes32 userOpHash
+    ) internal virtual override returns (uint256) {
+        return
+            _isValidSignature(userOpHash, userOp.signature)
+                ? ERC4337Utils.SIG_VALIDATION_SUCCESS
+                : ERC4337Utils.SIG_VALIDATION_FAILED;
+    }
+
+    /**
+     * @dev Validates the signature using the account's signer.S
+     */
+    function _validateSignature(bytes32 hash, bytes calldata signature) internal view virtual override returns (bool) {
+        (address recovered, ECDSA.RecoverError err, ) = ECDSA.tryRecover(hash, signature);
+        return signer() == recovered && err == ECDSA.RecoverError.NoError;
+    }
+
+    /// @inheritdoc ERC165
+    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
+        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
+    }
+}

contracts/account/AccountEIP7702.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {AccountECDSA} from "./AccountECDSA.sol";
+import {EIP712} from "../utils/cryptography/EIP712.sol";
+
+contract AccountEIP7702 is AccountECDSA {
+    constructor(string memory name, string memory version) AccountECDSA(address(this)) EIP712(name, version) {}
+}

contracts/account/AccountP256.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {PackedUserOperation} from "../interfaces/IERC4337.sol";
+import {AccountBase} from "./AccountBase.sol";
+import {ERC1271TypedSigner} from "../utils/cryptography/ERC1271TypedSigner.sol";
+import {P256} from "../utils/cryptography/P256.sol";
+import {ERC4337Utils} from "./utils/ERC4337Utils.sol";
+import {ERC721Holder} from "../token/ERC721/utils/ERC721Holder.sol";
+import {ERC1155HolderLean, IERC1155Receiver} from "../token/ERC1155/utils/ERC1155HolderLean.sol";
+import {ERC165} from "../utils/introspection/ERC165.sol";
+import {IERC165} from "../utils/introspection/IERC165.sol";
+
+/**
+ * @dev Account implementation using {P256} signatures and {ERC1271TypedSigner} for replay protection.
+ */
+abstract contract AccountP256 is ERC165, ERC1271TypedSigner, ERC721Holder, ERC1155HolderLean, AccountBase {
+    bytes32 private immutable _qx;
+    bytes32 private immutable _qy;
+
+    /**
+     * @dev Initializes the account with the P256 public key.
+     */
+    constructor(bytes32 qx, bytes32 qy) {
+        _qx = qx;
+        _qy = qy;
+    }
+
+    /**
+     * @dev Return the account's signer P256 public key.
+     */
+    function signer() public view virtual returns (bytes32 qx, bytes32 qy) {
+        return (_qx, _qy);
+    }
+
+    /**
+     * @dev Internal version of {validateUserOp} that relies on {_isValidSignature}.
+     */
+    function _validateUserOp(
+        PackedUserOperation calldata userOp,
+        bytes32 userOpHash
+    ) internal virtual override returns (uint256) {
+        return
+            _isValidSignature(userOpHash, userOp.signature)
+                ? ERC4337Utils.SIG_VALIDATION_SUCCESS
+                : ERC4337Utils.SIG_VALIDATION_FAILED;
+    }
+
+    /**
+     * @dev Validates the signature using the account's signer.
+     */
+    function _validateSignature(bytes32 hash, bytes calldata signature) internal view virtual override returns (bool) {
+        if (signature.length < 0x40) return false;
+        bytes32 r = bytes32(signature[0x00:0x20]);
+        bytes32 s = bytes32(signature[0x20:0x40]);
+        (bytes32 qx, bytes32 qy) = signer();
+        return P256.verify(hash, r, s, qx, qy);
+    }
+
+    /// @inheritdoc ERC165
+    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
+        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
+    }
+}