Add replayable applyOwnerChanges

Author: ilikesymmetry

src/AccountConfiguration.sol

@@ -35,9 +35,6 @@ contract AccountConfiguration {
     // INITIALIZATION
     ////////
 
-    /// @notice Designed for 7702 accounts to initialize on first use
-    function initializeAccount() external {}
-
     function createAccount(
         Owner[] calldata initialOwners,
         uint256 nonce,
@@ -82,21 +79,25 @@ contract AccountConfiguration {
     }
 
     function removeOwner(bytes32 ownerId) external {
-        require(isOwner(msg.sender, ownerId));
-        delete verifiers[ownerId][msg.sender];
-        emit OwnerRemoved(msg.sender, ownerId);
+        _removeOwner(msg.sender, ownerId);
     }
 
-    /// @notice Apply signed, replayable owner changes
-    function applyOwnerChanges(address account, uint64 startSequence, OwnerChange[] calldata ownerChanges) external {
-        // // validate signature
-        // if (startSequence != ownerChangeSequence[account]) revert InvalidOwnerChangeSequence(startSequence, ownerChangeSequence[account]);
-        // for (uint256 i; i < ownerChanges.length; i++) {
-        //     if (ownerChangeSequence[account] != ownerChanges[i].sequence) revert InvalidOwnerChange(ownerChanges[i]);
-        //     ownerChangeSequence[account]++;
-        //     // update account owner configuration
-        // }
-        // emit (account, ownerChanges);
+    /// @notice Apply replayable owner changes
+    function applyOwnerChanges(
+        address account,
+        OwnerChange[] calldata ownerChanges,
+        bytes32 ownerId,
+        bytes calldata verifyData
+    ) external {
+        bytes32 digest = keccak256(abi.encode(account, ownerChanges, ownerChangeSequence[account]++));
+        require(IVerifier(verifiers[ownerId][account]).verify(account, ownerId, digest, verifyData));
+        for (uint256 i; i < ownerChanges.length; i++) {
+            if (ownerChanges[i].add) {
+                _addOwner(account, ownerChanges[i].owner);
+            } else {
+                _removeOwner(account, ownerChanges[i].owner.id);
+            }
+        }
     }
 
     ////////
@@ -147,7 +148,7 @@ contract AccountConfiguration {
     }
 
     ////////
-    // INTERNAL FUNCTIONS
+    // INTERNALS
     ////////
 
     function _addOwner(address account, Owner calldata owner) internal {
@@ -156,4 +157,10 @@ contract AccountConfiguration {
         verifiers[owner.id][account] = owner.verifier;
         emit OwnerAdded(account, owner.id, owner.verifier);
     }
+
+    function _removeOwner(address account, bytes32 ownerId) internal {
+        require(isOwner(account, ownerId));
+        delete verifiers[ownerId][account];
+        emit OwnerRemoved(account, ownerId);
+    }
 }

src/verifiers/IVerifier.sol

@@ -2,8 +2,13 @@
 pragma solidity ^0.8.0;
 
 interface IVerifier {
-    function verify(address account, bytes32 ownerId, bytes32 hash, bytes calldata signature)
-        external
-        pure
-        returns (bool);
+    /// @notice Verify a signature for a given account, ownerId, hash, and data
+    ///
+    /// @param account The account to verify the signature for
+    /// @param ownerId The ownerId to verify the signature for
+    /// @param hash The hash to verify the signature for
+    /// @param data The data to verify the signature for
+    ///
+    /// @return true if the signature is valid, false otherwise
+    function verify(address account, bytes32 ownerId, bytes32 hash, bytes calldata data) external pure returns (bool);
 }

src/verifiers/Secp256K1Verifier.sol

@@ -4,16 +4,12 @@ pragma solidity ^0.8.0;
 import {IVerifier} from "./IVerifier.sol";
 
 contract Secp256K1Verifier is IVerifier {
-    function verify(address account, bytes32 ownerId, bytes32 hash, bytes calldata signature)
-        external
-        pure
-        returns (bool)
-    {
+    function verify(address account, bytes32 ownerId, bytes32 hash, bytes calldata data) external pure returns (bool) {
         // Commitment must be a valid address
         require(uint256(ownerId) < type(uint160).max && uint256(ownerId) > 0);
 
         // Signature must not be malleable
-        (uint8 v, bytes32 r, bytes32 s) = abi.decode(signature, (uint8, bytes32, bytes32));
+        (uint8 v, bytes32 r, bytes32 s) = abi.decode(data, (uint8, bytes32, bytes32));
         require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0); // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/ECDSA.sol#L176-L184
 
         // Recover address from signature