add natspec comments

Author: mllwchrry

contracts/accounts/AccountSubscriptionManager.sol

@@ -27,12 +27,14 @@ contract AccountSubscriptionManager is
         );
     }
 
+    /// @inheritdoc IAccountSubscriptionManager
     function addSubscriptionCreators(address[] calldata subscriptionCreators_) external onlyOwner {
         for (uint256 i = 0; i < subscriptionCreators_.length; ++i) {
             _addSubscriptionCreator(subscriptionCreators_[i]);
         }
     }
 
+    /// @inheritdoc IAccountSubscriptionManager
     function removeSubscriptionCreators(
         address[] calldata subscriptionCreators_
     ) external onlyOwner {

contracts/core/HelperDataRegistry.sol

@@ -4,7 +4,18 @@ pragma solidity ^0.8.28;
 import {EIP712Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
 import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 
+/**
+ * @title HelperDataRegistry
+ * @notice Registry for storing accounts helper data
+ */
 contract HelperDataRegistry is EIP712Upgradeable {
+    /**
+     * @notice Data structure storing helper data for an account.
+     * @param faceVersion Version of the facial data.
+     * @param objectVersion Version of the object data.
+     * @param helperDataVersion Version of the helper data.
+     * @param helperData Encoded bytes representing the helper data.
+     */
     struct HelperData {
         uint64 faceVersion;
         uint96 objectVersion;
@@ -24,14 +35,28 @@ contract HelperDataRegistry is EIP712Upgradeable {
             "HelperData(uint256 faceVersion,uint256 objectVersion,uint256 helperDataVersion,bytes helperData)"
         );
 
+    /**
+     * @notice Thrown when trying to set helper data for an account that already has it.
+     * @param signer The account address that already has helper data set.
+     */
     error HelperDataAlreadySet(address signer);
 
+    /**
+     * @notice Emitted when the helper data is set for an account.
+     * @param account The account address for which helper data was set.
+     */
     event HelperDataSet(address indexed account);
 
     function initialize() external initializer {
         __EIP712_init("HelperDataRegistry", "1");
     }
 
+    /**
+     * @notice A function to set helper data for an account.
+     * @dev Reverts if helper data is already set for the signer.
+     * @param helperData_ The helper data struct to set.
+     * @param signature_ The EIP-712 signature of the helper data signed by the account to set the data for.
+     */
     function setHelperData(HelperData calldata helperData_, bytes calldata signature_) external {
         bytes32 digest_ = hashHelperDataStruct(helperData_);
 
@@ -44,10 +69,20 @@ contract HelperDataRegistry is EIP712Upgradeable {
         emit HelperDataSet(signer_);
     }
 
+    /**
+     * @notice A function to retrieve the helper data for the provided account.
+     * @param account_ The account address to query.
+     * @return The `HelperData` struct associated with the account.
+     */
     function getHelperData(address account_) external view returns (HelperData memory) {
         return _getHelperDataRegistryStorage().accountsToHelperData[account_];
     }
 
+    /**
+     * @notice A function to compute the EIP-712 hash for a given `HelperData` struct.
+     * @param helperData_ The helper data to hash.
+     * @return The EIP-712 typed hash of the helper data struct.
+     */
     function hashHelperDataStruct(HelperData calldata helperData_) public view returns (bytes32) {
         return
             _hashTypedDataV4(
@@ -63,6 +98,11 @@ contract HelperDataRegistry is EIP712Upgradeable {
             );
     }
 
+    /**
+     * @notice A function to check whether helper data is already set for the provided account.
+     * @param account_ The account address to check.
+     * @return `true` if helper data exists for the account, `false` otherwise.
+     */
     function isHelperDataSet(address account_) public view returns (bool) {
         return
             _getHelperDataRegistryStorage().accountsToHelperData[account_].helperDataVersion != 0;

contracts/core/RecoveryManager.sol

@@ -7,6 +7,7 @@ import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
 import {ADeployerGuard} from "@solarity/solidity-lib/utils/ADeployerGuard.sol";
+import {IRecoveryProvider} from "@solarity/solidity-lib/interfaces/account-abstraction/IRecoveryProvider.sol";
 
 import {IRecoveryManager} from "../interfaces/core/IRecoveryManager.sol";
 import {ISubscriptionManager} from "../interfaces/core/ISubscriptionManager.sol";
@@ -54,39 +55,47 @@ contract RecoveryManager is IRecoveryManager, ADeployerGuard, OwnableUpgradeable
         _addStrategies(recoveryStrategies_);
     }
 
+    /// @inheritdoc IRecoveryManager
     function updateSubscriptionManagers(
         address[] calldata subscriptionManagersToUpdate_,
         bool isAdding_
     ) external onlyOwner {
         _updateSubscriptionManagers(subscriptionManagersToUpdate_, isAdding_);
     }
 
+    /// @inheritdoc IRecoveryManager
     function addRecoveryStrategies(address[] calldata newStrategies_) external onlyOwner {
         _addStrategies(newStrategies_);
     }
 
+    /// @inheritdoc IRecoveryManager
     function disableStrategy(uint256 strategyId_) external onlyOwner {
         _disableStrategy(strategyId_);
     }
 
+    /// @inheritdoc IRecoveryManager
     function enableStrategy(uint256 strategyId_) external onlyOwner {
         _enableStrategy(strategyId_);
     }
 
+    /// @inheritdoc IRecoveryProvider
     function subscribe(bytes memory recoveryData_) external payable {
         _subscribe(recoveryData_);
     }
 
+    /// @inheritdoc IRecoveryProvider
     function unsubscribe() external payable {
         _unsubscribe();
     }
 
+    /// @inheritdoc IRecoveryManager
     function resubscribe(bytes memory recoveryData_) external payable {
         _unsubscribe();
 
         _subscribe(recoveryData_);
     }
 
+    /// @inheritdoc IRecoveryProvider
     function recover(bytes memory object_, bytes memory proof_) external {
         RecoveryManagerStorage storage $ = _getRecoveryManagerStorage();
 
@@ -116,10 +125,12 @@ contract RecoveryManager is IRecoveryManager, ADeployerGuard, OwnableUpgradeable
         );
     }
 
+    /// @inheritdoc IRecoveryProvider
     function getRecoveryData(address account_) external view returns (bytes memory) {
         return abi.encode(getRecoveryMethods(account_));
     }
 
+    /// @inheritdoc IRecoveryManager
     function getRecoveryMethods(
         address account_
     ) public view returns (RecoveryMethod[] memory recoveryMethods_) {
@@ -137,18 +148,22 @@ contract RecoveryManager is IRecoveryManager, ADeployerGuard, OwnableUpgradeable
         }
     }
 
+    /// @inheritdoc IRecoveryManager
     function subscriptionManagerExists(address subscriptionManager_) public view returns (bool) {
         return _getRecoveryManagerStorage().subscriptionManagers.contains(subscriptionManager_);
     }
 
+    /// @inheritdoc IRecoveryManager
     function getStrategyStatus(uint256 strategyId_) public view returns (StrategyStatus) {
         return _getRecoveryManagerStorage().strategiesData[strategyId_].status;
     }
 
+    /// @inheritdoc IRecoveryManager
     function getStrategy(uint256 strategyId_) public view returns (address) {
         return _getRecoveryManagerStorage().strategiesData[strategyId_].strategy;
     }
 
+    /// @inheritdoc IRecoveryManager
     function isActiveStrategy(uint256 strategyId_) public view returns (bool) {
         return getStrategyStatus(strategyId_) == StrategyStatus.Active;
     }

contracts/core/strategies/ARecoveryStrategy.sol

@@ -13,8 +13,6 @@ abstract contract ARecoveryStrategy is IRecoveryStrategy, NoncesUpgradeable {
         address recoveryManagerAddr;
     }
 
-    error NotARecoveryManager(address account);
-
     modifier onlyRecoveryManager() {
         _onlyRecoveryManager();
         _;
@@ -36,6 +34,7 @@ abstract contract ARecoveryStrategy is IRecoveryStrategy, NoncesUpgradeable {
         _getARecoveryStrategyStorage().recoveryManagerAddr = recoveryManagerAddr_;
     }
 
+    /// @inheritdoc IRecoveryStrategy
     function recoverAccount(
         address account_,
         bytes memory object_,
@@ -44,10 +43,12 @@ abstract contract ARecoveryStrategy is IRecoveryStrategy, NoncesUpgradeable {
         _recoverAccount(account_, object_, recoveryData_);
     }
 
+    /// @inheritdoc IRecoveryStrategy
     function getRecoveryManager() public view virtual returns (address) {
         return _getARecoveryStrategyStorage().recoveryManagerAddr;
     }
 
+    /// @inheritdoc IRecoveryStrategy
     function validateRecoveryData(bytes memory recoveryData_) external view {
         _validateRecoveryData(recoveryData_);
     }

contracts/core/strategies/SignatureRecoveryStrategy.sol

@@ -24,6 +24,7 @@ contract SignatureRecoveryStrategy is
         __ARecoveryStrategy_init(recoveryManagerAddr_);
     }
 
+    /// @inheritdoc ISignatureRecoveryStrategy
     function hashSignatureRecovery(
         address account_,
         bytes memory object_,

contracts/core/subscription/BaseSubscriptionManager.sol

@@ -36,11 +36,6 @@ abstract contract BaseSubscriptionManager is
         EnumerableSet.AddressSet subscriptionCreators;
     }
 
-    error SubscriptionCreatorAlreadyAdded(address subscriptionCreator);
-
-    event SubscriptionCreatorAdded(address indexed subscriptionCreator);
-    event SubscriptionCreatorRemoved(address indexed subscriptionCreator);
-
     modifier onlySubscriptionCreator() {
         _onlySubscriptionCreator(msg.sender);
         _;
@@ -76,14 +71,21 @@ abstract contract BaseSubscriptionManager is
         __SignatureSubscriptionModule_init(sigSubscriptionInitData_);
     }
 
+    /// @inheritdoc ISubscriptionManager
     function pause() public virtual onlyOwner {
         _pause();
     }
 
+    /// @inheritdoc ISubscriptionManager
     function unpause() public virtual onlyOwner {
         _unpause();
     }
 
+    /**
+     * @notice A function to update payment token configurations.
+     * @param paymentTokenEntries_ An array of payment token configurations
+              containing token addresses and their base costs.
+     */
     function updatePaymentTokens(
         PaymentTokenUpdateEntry[] calldata paymentTokenEntries_
     ) public virtual onlyOwner {
@@ -95,16 +97,31 @@ abstract contract BaseSubscriptionManager is
         }
     }
 
+    /**
+     * @notice A function to remove supported payment tokens.
+     * @param tokensToRemove_ An array of token addresses to remove.
+     */
     function removePaymentTokens(address[] calldata tokensToRemove_) public virtual onlyOwner {
         for (uint256 i = 0; i < tokensToRemove_.length; ++i) {
             _removePaymentToken(tokensToRemove_[i]);
         }
     }
 
+    /**
+     * @notice A function to update the duration-based factor for adjusting subscription costs.
+     * @param duration_ Subscription duration to update the factor for.
+     * @param factor_ Updated multiplicative factor applied to the base cost.
+     */
     function updateDurationFactor(uint64 duration_, uint256 factor_) public virtual onlyOwner {
         _updateDurationFactor(duration_, factor_);
     }
 
+    /**
+     * @notice A function to withdraw tokens from the subscription manager.
+     * @param tokenAddr_ Payment token address to withdraw.
+     * @param to_ Withdrawal recipient address.
+     * @param amount_ Amount of tokens to withdraw.
+     */
     function withdrawTokens(
         address tokenAddr_,
         address to_,
@@ -113,26 +130,41 @@ abstract contract BaseSubscriptionManager is
         _withdrawTokens(tokenAddr_, to_, amount_);
     }
 
+    /**
+     * @notice A function to update supported SBTs used for subscription purchases.
+     * @param sbtEntries_ An array of SBT configurations containing
+              token addresses and their subscription durations.
+     */
     function updateSBTs(SBTUpdateEntry[] calldata sbtEntries_) public virtual onlyOwner {
         for (uint256 i = 0; i < sbtEntries_.length; ++i) {
             _updateSBT(sbtEntries_[i].sbt, sbtEntries_[i].subscriptionDurationPerToken);
         }
     }
 
+    /**
+     * @notice A function to remove supported SBTs.
+     * @param sbtsToRemove_ An array of SBT addresses to remove.
+     */
     function removeSBTs(address[] calldata sbtsToRemove_) public virtual onlyOwner {
         for (uint256 i = 0; i < sbtsToRemove_.length; ++i) {
             _removeSBT(sbtsToRemove_[i]);
         }
     }
 
+    /**
+     * @notice A function to set a new subscription signer used for signature-based subscriptions.
+     * @param newSigner_ Address of the new subscription signer.
+     */
     function setSubscriptionSigner(address newSigner_) public virtual onlyOwner {
         _setSubscriptionSigner(newSigner_);
     }
 
+    /// @inheritdoc ISubscriptionManager
     function createSubscription(address account_) public virtual onlySubscriptionCreator {
         _createSubscription(account_);
     }
 
+    /// @inheritdoc ITokensPaymentModule
     function buySubscription(
         address account_,
         address token_,
@@ -148,6 +180,7 @@ abstract contract BaseSubscriptionManager is
         super.buySubscription(account_, token_, duration_);
     }
 
+    /// @inheritdoc ISBTPaymentModule
     function buySubscriptionWithSBT(
         address vault_,
         address sbt_,
@@ -156,6 +189,7 @@ abstract contract BaseSubscriptionManager is
         super.buySubscriptionWithSBT(vault_, sbt_, tokenId_);
     }
 
+    /// @inheritdoc ISignatureSubscriptionModule
     function buySubscriptionWithSignature(
         address vault_,
         uint64 duration_,
@@ -170,14 +204,17 @@ abstract contract BaseSubscriptionManager is
         super.buySubscriptionWithSignature(vault_, duration_, signature_);
     }
 
+    /// @inheritdoc ISubscriptionManager
     function implementation() external view returns (address) {
         return ERC1967Utils.getImplementation();
     }
 
+    /// @inheritdoc ISubscriptionManager
     function getSubscriptionCreators() public view virtual returns (address[] memory) {
         return _getBaseSubscriptionManagerStorage().subscriptionCreators.values();
     }
 
+    /// @inheritdoc ISubscriptionManager
     function isSubscriptionCreator(address account_) public view virtual returns (bool) {
         return _getBaseSubscriptionManagerStorage().subscriptionCreators.contains(account_);
     }

contracts/core/subscription/modules/BaseSubscriptionModule.sol

@@ -23,22 +23,27 @@ contract BaseSubscriptionModule is IBaseSubscriptionModule {
         }
     }
 
+    /// @inheritdoc IBaseSubscriptionModule
     function hasSubscription(address account_) public view virtual returns (bool) {
         return getSubscriptionStartTime(account_) > 0;
     }
 
+    /// @inheritdoc IBaseSubscriptionModule
     function hasActiveSubscription(address account_) public view virtual returns (bool) {
         return block.timestamp < getSubscriptionEndTime(account_);
     }
 
+    /// @inheritdoc IBaseSubscriptionModule
     function hasSubscriptionDebt(address account_) public view virtual returns (bool) {
         return !hasActiveSubscription(account_) && hasSubscription(account_);
     }
 
+    /// @inheritdoc IBaseSubscriptionModule
     function getSubscriptionStartTime(address account_) public view virtual returns (uint64) {
         return _getAccountSubscriptionData(account_).startTime;
     }
 
+    /// @inheritdoc IBaseSubscriptionModule
     function getSubscriptionEndTime(address account_) public view virtual returns (uint64) {
         if (!hasSubscription(account_)) {
             return uint64(block.timestamp);