Finish docs

contracts/account/draft-AccountBase.sol

@@ -103,7 +103,7 @@ abstract contract AccountBase is IAccount, IAccountExecute {
     function _validateUserOp(
         PackedUserOperation calldata userOp,
         bytes32 userOpSignedHash
-    ) internal virtual returns (uint256 validationData);
+    ) internal view virtual returns (uint256 validationData);
 
     /**
      * @dev Sends the missing funds for executing the user operation to the {entrypoint}.

contracts/account/draft-AccountECDSA.sol

@@ -16,6 +16,12 @@ import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.s
 
 /**
  * @dev Account implementation using {ECDSA} signatures and {ERC7739Signer} for replay protection.
+ *
+ * An {_initializeSigner} function is provided to set the account's signer address. Doing so it's
+ * easier for a factory, whose likely to use initializable clones of this contract.
+ *
+ * IMPORTANT: Avoiding to call {_initializeSigner} either during construction (if used standalone)
+ * or during initialization (if used as a clone) may leave the account unusable.
  */
 abstract contract AccountECDSA is ERC165, ERC7739Signer, ERC721Holder, ERC1155HolderLean, AccountBase {
     using MessageHashUtils for bytes32;
@@ -28,7 +34,7 @@ abstract contract AccountECDSA is ERC165, ERC7739Signer, ERC721Holder, ERC1155Ho
     address private _signer;
 
     /**
-     * @dev Initializes the account with the address of the native signer.
+     * @dev Initializes the account with the address of the native signer. This function is called only once.
      */
     function _initializeSigner(address signerAddr) internal {
         if (_signer != address(0)) revert AccountECDSAUninitializedSigner(signerAddr);

contracts/account/draft-AccountP256.sol

@@ -15,6 +15,12 @@ import {ERC7739Signer} from "../utils/cryptography/draft-ERC7739Signer.sol";
 
 /**
  * @dev Account implementation using {P256} signatures and {ERC7739Signer} for replay protection.
+ *
+ * An {_initializeSigner} function is provided to set the account's signer address. Doing so it's
+ * easier for a factory, whose likely to use initializable clones of this contract.
+ *
+ * IMPORTANT: Avoiding to call {_initializeSigner} either during construction (if used standalone)
+ * or during initialization (if used as a clone) may leave the account unusable.
  */
 abstract contract AccountP256 is ERC165, ERC7739Signer, ERC721Holder, ERC1155HolderLean, AccountBase {
     using MessageHashUtils for bytes32;

contracts/account/draft-AccountRSA.sol

@@ -16,10 +16,11 @@ import {ERC7739Signer} from "../utils/cryptography/draft-ERC7739Signer.sol";
 /**
  * @dev Account implementation using {RSA} signatures and {ERC7739Signer} for replay protection.
  *
- * NOTE: Storing `_e` and `_n` in regular storage violate ERC-7562 validation rules if the contract
- * is used as an ERC-1271 signer during the validation phase of a different account contract.
- * Consider deploying this contract through a factory that sets `_e` and `_n` as immutable arguments
- * (see {Clones-cloneDeterministicWithImmutableArgs}).
+ * An {_initializeSigner} function is provided to set the account's signer address. Doing so it's
+ * easier for a factory, whose likely to use initializable clones of this contract.
+ *
+ * IMPORTANT: Avoiding to call {_initializeSigner} either during construction (if used standalone)
+ * or during initialization (if used as a clone) may leave the account unusable.
  */
 abstract contract AccountRSA is ERC165, ERC7739Signer, ERC721Holder, ERC1155HolderLean, AccountBase {
     using MessageHashUtils for bytes32;

contracts/mocks/account/AccountBaseMock.sol

@@ -17,11 +17,4 @@ contract AccountBaseMock is AccountBase {
                 ? ERC4337Utils.SIG_VALIDATION_SUCCESS
                 : ERC4337Utils.SIG_VALIDATION_FAILED;
     }
-
-    function _userOpSignedHash(
-        PackedUserOperation calldata /* userOp */,
-        bytes32 userOpHash
-    ) internal pure override returns (bytes32) {
-        return userOpHash;
-    }
 }

contracts/mocks/docs/account/MyAccountCustom.sol

@@ -0,0 +1,44 @@
+// contracts/MyAccountCustom.sol
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import {ERC4337Utils, PackedUserOperation} from "@openzeppelin/contracts/account/utils/draft-ERC4337Utils.sol";
+import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import {AccountBase} from "../../../account/draft-AccountBase.sol";
+import {ERC7739Signer} from "../../../utils/cryptography/draft-ERC7739Signer.sol";
+
+contract MyAccountCustom is ERC7739Signer, AccountBase, Initializable {
+    /**
+     * NOTE: EIP-712 domain is set at construction because each account clone
+     * will recalculate its domain separator based on their own address.
+     */
+    constructor() EIP712("MyAccountCustom", "1") {
+        _disableInitializers();
+    }
+
+    /// @dev Set up the account (e.g. load public keys to storage).
+    function initialize() public virtual initializer {
+        // Custom initialization logic
+    }
+
+    /// @dev Receives an `userOpSignedHash` to validate. See {_userOpSignedHash}.
+    function _validateUserOp(
+        PackedUserOperation calldata userOp,
+        bytes32 userOpSignedHash
+    ) internal view virtual override returns (uint256) {
+        return
+            _isValidSignature(userOpSignedHash, userOp.signature)
+                ? ERC4337Utils.SIG_VALIDATION_SUCCESS
+                : ERC4337Utils.SIG_VALIDATION_FAILED;
+    }
+
+    /// @dev Receives a hash wrapped in an EIP-712 domain separator.
+    function _validateNestedEIP712Signature(
+        bytes32 hash,
+        bytes calldata signature
+    ) internal view virtual override returns (bool) {
+        // Custom signing logic
+    }
+}

contracts/mocks/docs/account/MyAccountECDSA.sol

@@ -0,0 +1,22 @@
+// contracts/MyAccountECDSA.sol
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import {AccountECDSA} from "../../../account/draft-AccountECDSA.sol";
+
+contract MyAccountECDSA is AccountECDSA, Initializable {
+    /**
+     * NOTE: EIP-712 domain is set at construction because each account clone
+     * will recalculate its domain separator based on their own address.
+     */
+    constructor() EIP712("MyAccountECDSA", "1") {
+        _disableInitializers();
+    }
+
+    function initializeSigner(address signerAddr) public virtual initializer {
+        _initializeSigner(signerAddr);
+    }
+}

contracts/mocks/docs/account/MyAccountP256.sol

@@ -0,0 +1,22 @@
+// contracts/MyAccountP256.sol
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import {AccountP256} from "../../../account/draft-AccountP256.sol";
+
+contract MyAccountP256 is AccountP256, Initializable {
+    /**
+     * NOTE: EIP-712 domain is set at construction because each account clone
+     * will recalculate its domain separator based on their own address.
+     */
+    constructor() EIP712("MyAccountP256", "1") {
+        _disableInitializers();
+    }
+
+    function initializeSigner(bytes32 qx, bytes32 qy) public virtual initializer {
+        _initializeSigner(qx, qy);
+    }
+}

contracts/mocks/docs/account/MyAccountRSA.sol

@@ -0,0 +1,22 @@
+// contracts/MyAccountRSA.sol
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import {AccountRSA} from "../../../account/draft-AccountRSA.sol";
+
+contract MyAccountRSA is AccountRSA, Initializable {
+    /**
+     * NOTE: EIP-712 domain is set at construction because each account clone
+     * will recalculate its domain separator based on their own address.
+     */
+    constructor() EIP712("MyAccountRSA", "1") {
+        _disableInitializers();
+    }
+
+    function initializeSigner(bytes memory e, bytes memory n) public virtual initializer {
+        _initializeSigner(e, n);
+    }
+}

contracts/mocks/docs/account/MyFactoryAccountECDSA.sol

@@ -0,0 +1,37 @@
+// contracts/MyFactoryAccountECDSA.sol
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {MyAccountECDSA} from "./MyAccountECDSA.sol";
+
+/**
+ * @dev An abstract factory contract to create ECDSA accounts on demand.
+ */
+contract MyFactoryAccountECDSA {
+    using Clones for address;
+
+    address private immutable _impl = address(new MyAccountECDSA());
+
+    /// @dev Predict the address of the account
+    function predictAddress(bytes32 salt) public view returns (address) {
+        return _impl.predictDeterministicAddress(salt, address(this));
+    }
+
+    /// @dev Create clone accounts on demand
+    function cloneAndInitialize(bytes32 salt, address signer) public returns (address) {
+        return _cloneAndInitialize(salt, signer);
+    }
+
+    /// @dev Create clone accounts on demand and return the address. Uses `signer` to initialize the clone.
+    function _cloneAndInitialize(bytes32 salt, address signer) internal returns (address) {
+        address predicted = predictAddress(salt);
+        if (predicted.code.length == 0) {
+            _impl.cloneDeterministic(salt);
+            Address.functionCall(predicted, abi.encodeCall(MyAccountECDSA.initializeSigner, (signer)));
+        }
+        return predicted;
+    }
+}

docs/modules/ROOT/nav.adoc

@@ -1,2 +1,3 @@
 * xref:index.adoc[Overview]
+* xref:account-abstraction.adoc[Account Abstraction]
 * xref:utilities.adoc[Utilities]