Update ERC7947 interface (#154)

* Update ERC7947 interface

* Fix unit tests

Author: Hrom131

contracts/account-abstraction/AAccountRecovery.sol

@@ -13,7 +13,7 @@ import {IRecoveryProvider} from "../interfaces/account-abstraction/IRecoveryProv
  * You may use this module as a base contract for your own account recovery mechanism.
  *
  * The Account Recovery module allows to add recovery providers to the account.
- * The recovery providers are used to recover the account ownership.
+ * The recovery providers are used to recover the account access.
  *
  * For more information please refer to [EIP-7947](https://eips.ethereum.org/EIPS/eip-7947).
  */
@@ -35,20 +35,23 @@ abstract contract AAccountRecovery is IAccountRecovery {
     /**
      * @inheritdoc IAccountRecovery
      */
-    function addRecoveryProvider(address provider_, bytes memory recoveryData_) external virtual;
+    function addRecoveryProvider(
+        address provider_,
+        bytes memory recoveryData_
+    ) external payable virtual;
 
     /**
      * @inheritdoc IAccountRecovery
      */
-    function removeRecoveryProvider(address provider_) external virtual;
+    function removeRecoveryProvider(address provider_) external payable virtual;
 
     /**
      * @inheritdoc IAccountRecovery
      */
-    function recoverOwnership(
-        address newOwner,
-        address provider,
-        bytes memory proof
+    function recoverAccess(
+        bytes memory subject_,
+        address provider_,
+        bytes memory proof_
     ) external virtual returns (bool);
 
     /**
@@ -99,20 +102,18 @@ abstract contract AAccountRecovery is IAccountRecovery {
     }
 
     /**
-     * @notice Should be called in the `recoverOwnership` function before updating the account owner
+     * @notice Should be called in the `recoverAccess` function before updating the account access
      */
     function _validateRecovery(
-        address newOwner_,
+        bytes memory object_,
         address provider_,
         bytes memory proof_
     ) internal virtual {
-        if (newOwner_ == address(0)) revert ZeroAddress();
-
         AAccountRecoveryStorage storage $ = _getAAccountRecoveryStorage();
 
         if (!$.recoveryProviders.contains(provider_)) revert ProviderNotRegistered(provider_);
 
-        IRecoveryProvider(provider_).recover(newOwner_, proof_);
+        IRecoveryProvider(provider_).recover(object_, proof_);
     }
 
     /**

contracts/interfaces/account-abstraction/IAccountRecovery.sol

@@ -9,38 +9,38 @@ pragma solidity ^0.8.21;
  * For more information please refer to [EIP-7947](https://eips.ethereum.org/EIPS/eip-7947).
  */
 interface IAccountRecovery {
-    event OwnershipRecovered(address indexed oldOwner, address indexed newOwner);
+    event AccessRecovered(bytes subject);
     event RecoveryProviderAdded(address indexed provider);
     event RecoveryProviderRemoved(address indexed provider);
 
     /**
      * @notice A function to add a new recovery provider.
      * SHOULD be access controlled.
      *
-     * @param provider the address of a recovery provider (ZKP verifier) to add.
-     * @param recoveryData custom data (commitment) for the recovery provider.
+     * @param provider_ the address of a recovery provider (ZKP verifier) to add.
+     * @param recoveryData_ custom data (commitment) for the recovery provider.
      */
-    function addRecoveryProvider(address provider, bytes memory recoveryData) external;
+    function addRecoveryProvider(address provider_, bytes memory recoveryData_) external payable;
 
     /**
      * @notice A function to remove an existing recovery provider.
      * SHOULD be access controlled.
      *
-     * @param provider the address of a previously added recovery provider to remove.
+     * @param provider_ the address of a previously added recovery provider to remove.
      */
-    function removeRecoveryProvider(address provider) external;
+    function removeRecoveryProvider(address provider_) external payable;
 
     /**
-     * @notice A non-view function to recover ownership of a smart account.
-     * @param newOwner the address of a new owner.
-     * @param provider the address of a recovery provider.
-     * @param proof an encoded proof of recovery (ZKP/ZKAI, signature, etc).
+     * @notice A non-view function to recover access of a smart account.
+     * @param subject_ the recovery subject (encoded owner address, access control role, etc).
+     * @param provider_ the address of a recovery provider.
+     * @param proof_ an encoded proof of recovery (ZKP/ZKAI, signature, etc).
      * @return `true` if recovery is successful, `false` (or revert) otherwise.
      */
-    function recoverOwnership(
-        address newOwner,
-        address provider,
-        bytes memory proof
+    function recoverAccess(
+        bytes memory subject_,
+        address provider_,
+        bytes memory proof_
     ) external returns (bool);
 
     /**

contracts/interfaces/account-abstraction/IRecoveryProvider.sol

@@ -16,31 +16,31 @@ interface IRecoveryProvider {
      * @notice A function that "subscribes" a smart account (msg.sender) to a recovery provider.
      * SHOULD process and assign the `recoveryData` to the `msg.sender`.
      *
-     * @param recoveryData a recovery commitment (hash/ZKP public output) to be used
+     * @param recoveryData_ a recovery commitment (hash/ZKP public output) to be used
      * in the `recover` function to check a recovery proof validity.
      */
-    function subscribe(bytes memory recoveryData) external;
+    function subscribe(bytes memory recoveryData_) external payable;
 
     /**
      * @notice A function that revokes a smart account subscription.
      */
-    function unsubscribe() external;
+    function unsubscribe() external payable;
 
     /**
      * @notice A function that checks if a recovery of a smart account (msg.sender)
      * to the `newOwner` is possible.
      * SHOULD use `msg.sender`'s `recoveryData` to check the `proof` validity.
      *
-     * @param newOwner the new owner to recover the `msg.sender` ownership to.
-     * @param proof the recovery proof.
+     * @param object_ the new object (may be different to subject) to recover the `msg.sender` access to.
+     * @param proof_ the recovery proof.
      */
-    function recover(address newOwner, bytes memory proof) external;
+    function recover(bytes memory object_, bytes memory proof_) external;
 
     /**
      * @notice A function to get a recovery data (commitment) of an account.
      *
-     * @param account the account to get the recovery data of.
+     * @param account_ the account to get the recovery data of.
      * @return the associated recovery data.
      */
-    function getRecoveryData(address account) external view returns (bytes memory);
+    function getRecoveryData(address account_) external view returns (bytes memory);
 }

contracts/mock/account-abstraction/AccountRecoveryMock.sol

@@ -4,20 +4,27 @@ pragma solidity ^0.8.21;
 import {AAccountRecovery} from "../../account-abstraction/AAccountRecovery.sol";
 
 contract AccountRecoveryMock is AAccountRecovery {
-    function addRecoveryProvider(address provider_, bytes memory recoveryData_) external override {
+    function addRecoveryProvider(
+        address provider_,
+        bytes memory recoveryData_
+    ) external payable override {
         _addRecoveryProvider(provider_, recoveryData_);
     }
 
-    function removeRecoveryProvider(address provider_) external override {
+    function removeRecoveryProvider(address provider_) external payable override {
         _removeRecoveryProvider(provider_);
     }
 
-    function validateRecovery(address newOwner_, address provider_, bytes memory proof_) external {
-        _validateRecovery(newOwner_, provider_, proof_);
+    function validateRecovery(
+        bytes memory object_,
+        address provider_,
+        bytes memory proof_
+    ) external {
+        _validateRecovery(object_, provider_, proof_);
     }
 
-    function recoverOwnership(
-        address,
+    function recoverAccess(
+        bytes memory,
         address,
         bytes memory
     ) external pure override returns (bool) {}

contracts/mock/account-abstraction/RecoveryProviderMock.sol

@@ -4,17 +4,17 @@ pragma solidity ^0.8.21;
 contract RecoveryProviderMock {
     event SubscribeCalled(bytes recoveryData_);
     event UnsubscribeCalled();
-    event RecoverCalled(address newOwner, bytes proof);
+    event RecoverCalled(bytes object, bytes proof);
 
-    function subscribe(bytes memory recoveryData_) external {
+    function subscribe(bytes memory recoveryData_) external payable {
         emit SubscribeCalled(recoveryData_);
     }
 
-    function unsubscribe() external {
+    function unsubscribe() external payable {
         emit UnsubscribeCalled();
     }
 
-    function recover(address newOwner_, bytes memory proof_) external {
-        emit RecoverCalled(newOwner_, proof_);
+    function recover(bytes memory object_, bytes memory proof_) external {
+        emit RecoverCalled(object_, proof_);
     }
 }

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@solarity/solidity-lib",
-  "version": "3.1.6",
+  "version": "3.1.7",
   "license": "MIT",
   "author": "Distributed Lab",
   "readme": "README.md",

package.json

@@ -1,25 +1,20 @@
 import { expect } from "chai";
 import { ethers } from "hardhat";
 
-import { SignerWithAddress } from "@nomicfoundation/hardhat-ethers/signers";
-
 import { AccountRecoveryMock, RecoveryProviderMock } from "@/generated-types/ethers";
 import { Reverter } from "@/test/helpers/reverter";
 
 describe("AccountRecovery", () => {
   const reverter = new Reverter();
 
-  let OWNER: SignerWithAddress;
-
   let accountRecovery: AccountRecoveryMock;
   let provider1: RecoveryProviderMock;
   let provider2: RecoveryProviderMock;
 
+  const OBJECT_DATA = "0x5678";
   const RECOVERY_DATA = "0x1234";
 
   before(async () => {
-    [OWNER] = await ethers.getSigners();
-
     const AccountRecoveryMock = await ethers.getContractFactory("AccountRecoveryMock");
     accountRecovery = await AccountRecoveryMock.deploy();
 
@@ -93,21 +88,15 @@ describe("AccountRecovery", () => {
     });
 
     it("should call a `recover` function of a recovery provider", async () => {
-      const tx = await accountRecovery.validateRecovery(OWNER, provider1, RECOVERY_DATA);
-      await expect(tx).to.emit(provider1, "RecoverCalled").withArgs(OWNER, RECOVERY_DATA);
+      const tx = await accountRecovery.validateRecovery(OBJECT_DATA, provider1, RECOVERY_DATA);
+      await expect(tx).to.emit(provider1, "RecoverCalled").withArgs(OBJECT_DATA, RECOVERY_DATA);
     });
 
     it("should revert if a provider is not added", async () => {
-      await expect(accountRecovery.validateRecovery(OWNER, provider2, RECOVERY_DATA))
+      await expect(accountRecovery.validateRecovery(OBJECT_DATA, provider2, RECOVERY_DATA))
         .to.be.revertedWithCustomError(accountRecovery, "ProviderNotRegistered")
         .withArgs(provider2);
     });
-
-    it("should revert if a new owner is zero address", async () => {
-      await expect(
-        accountRecovery.validateRecovery(ethers.ZeroAddress, provider1, RECOVERY_DATA),
-      ).to.be.revertedWithCustomError(accountRecovery, "ZeroAddress");
-    });
   });
 
   describe("recoveryProviderAdded", () => {