Improve docs

Author: ernestognw

contracts/mocks/docs/account/MyAccountERC7913.sol

@@ -0,0 +1,30 @@
+// contracts/MyAccount.sol
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Account} from "../../../account/Account.sol";
+import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import {ERC721Holder} from "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
+import {ERC1155Holder} from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
+import {ERC7739} from "../../../utils/cryptography/ERC7739.sol";
+import {ERC7821} from "../../../account/extensions/ERC7821.sol";
+import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import {SignerERC7913} from "../../../utils/cryptography/SignerERC7913.sol";
+
+contract MyAccount7913 is Account, SignerERC7913, ERC7739, ERC7821, ERC721Holder, ERC1155Holder, Initializable {
+    constructor() EIP712("MyAccount7913", "1") {}
+
+    function initialize(bytes memory signer) public initializer {
+        _setSigner(signer);
+    }
+
+    /// @dev Allows the entry point as an authorized executor.
+    function _erc7821AuthorizedExecutor(
+        address caller,
+        bytes32 mode,
+        bytes calldata executionData
+    ) internal view virtual override returns (bool) {
+        return caller == address(entryPoint()) || super._erc7821AuthorizedExecutor(caller, mode, executionData);
+    }
+}

contracts/utils/cryptography/SignerERC7913.sol

@@ -6,39 +6,44 @@ import {AbstractSigner} from "./AbstractSigner.sol";
 import {ERC7913Utils} from "./ERC7913Utils.sol";
 
 /**
- * @dev Implementation of {AbstractSigner} that supports ERC-7913 signers.
+ * @dev Implementation of {AbstractSigner} using
+ * https://eips.ethereum.org/EIPS/eip-7913[ERC-7913] signature verification.
  *
- * For {Account} usage, an {_setSigner} function is provided to set the ERC-7913 formatted {signer}.
- * Doing so it's easier for a factory, whose likely to use initializable clones of this contract.
+ * For {Account} usage, a {_setSigner} function is provided to set the ERC-7913 formatted {signer}.
+ * Doing so is easier for a factory, who is likely to use initializable clones of this contract.
+ *
+ * The signer is a `bytes` object that concatenates a verifier address and a key: `verifier || key`.
  *
  * Example of usage:
  *
  * ```solidity
  * contract MyAccountERC7913 is Account, SignerERC7913, Initializable {
  *     constructor() EIP712("MyAccountERC7913", "1") {}
  *
- *     function initialize(bytes memory signer) public initializer {
- *       _setSigner(signer);
+ *     function initialize(bytes memory signer_) public initializer {
+ *       _setSigner(signer_);
  *     }
  * }
  * ```
  *
- * IMPORTANT: Avoiding to call {_setSigner} either during construction (if used standalone)
+ * IMPORTANT: Failing to call {_setSigner} either during construction (if used standalone)
  * or during initialization (if used as a clone) may leave the signer either front-runnable or unusable.
  */
 
 abstract contract SignerERC7913 is AbstractSigner {
     bytes private _signer;
 
+    /// @dev Sets the signer (i.e. `verifier || key`) with an ERC-7913 formatted signer.
     function _setSigner(bytes memory signer_) internal {
         _signer = signer_;
     }
 
+    /// @dev Return the ERC-7913 signer (i.e. `verifier || key`).
     function signer() public view virtual returns (bytes memory) {
         return _signer;
     }
 
-    /// @inheritdoc AbstractSigner
+    /// @dev Verifies a signature using {ERC7913Utils.isValidSignatureNow} with {signer}, `hash` and `signature`.
     function _rawSignatureValidation(
         bytes32 hash,
         bytes calldata signature

docs/modules/ROOT/pages/account-abstraction.adoc

@@ -29,7 +29,7 @@ To setup an account, you can either bring your own validation logic and start wi
 
 === Selecting a signer
 
-The library includes specializations of the `AbstractSigner` contract that use custom digital signature verification algorithms. These are xref:api:utils.adoc#SignerECDSA[`SignerECDSA`], xref:api:utils.adoc#SignerP256[`SignerP256`] and xref:api:utils.adoc#SignerRSA[`SignerRSA`].
+The library includes specializations of the `AbstractSigner` contract that use custom digital signature verification algorithms. These are xref:api:utils.adoc#SignerECDSA[`SignerECDSA`], xref:api:utils.adoc#SignerP256[`SignerP256`], xref:api:utils.adoc#SignerRSA[`SignerRSA`], xref:api:utils.adoc#SignerERC7702[`SignerERC7702`], and xref:api:utils.adoc#SignerERC7913[`SignerERC7913`].
 
 Since smart accounts are deployed by a factory, the best practice is to create https://docs.openzeppelin.com/contracts/5.x/api/proxy#minimal_clones[minimal clones] of initializable contracts. These signer implementations provide an initializable design by default so that the factory can interact with the account to set it up after deployment in a single transaction.
 
@@ -56,6 +56,13 @@ Similarly, some government and corporate public key infrastructures use RSA for
 include::api:example$account/MyAccountRSA.sol[]
 ----
 
+For more advanced use cases where you need to support keys that don't have their own Ethereum address (like hardware devices or non-Ethereum cryptographic curves), you can use xref:api:utils.adoc#SignerERC7913[`SignerERC7913`]. This implementation allows for signature verification using ERC-7913 compatible verifiers.
+
+[source,solidity]
+----
+include::api:example$account/MyAccountERC7913.sol[]
+----
+
 == Account Factory
 
 The first time a user sends an user operation, the account will be created deterministically (i.e. its code and address can be predicted) using the the `initCode` field in the UserOperation. This field contains both the address of a smart contract (the factory) and the data required to call it and deploy the smart account.