Readd revoke, explicit eoa verifier (#10)

chunter-cb · web-flow · commit 0576eef15f6d · 2026-04-02T19:29:36.000-04:00
diff --git a/src/AccountConfiguration.sol b/src/AccountConfiguration.sol
@@ -63,6 +63,9 @@ contract AccountConfiguration is IAccountConfiguration {
     /// @notice Owner can change account owners
     uint8 public constant SCOPE_CHANGE_OWNERS = 0x08;
 
+    /// @notice Sentinel verifier written on self-ownerId revocation to block implicit re-authorization.
+    address public constant REVOKED_VERIFIER = address(1);
+
     // ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡
     // STORAGE
     // ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡
@@ -236,7 +239,10 @@ contract AccountConfiguration is IAccountConfiguration {
     }
 
     function isOwner(address account, bytes32 ownerId) public view returns (bool) {
-        return _ownerConfig[ownerId][account].verifier != address(0);
+        address verifier = _ownerConfig[ownerId][account].verifier;
+        if (verifier > REVOKED_VERIFIER) return true;
+        // Implicit EOA: self-ownerId with truly empty slot
+        return verifier == address(0) && ownerId == bytes32(bytes20(account));
     }
 
     function getOwnerConfig(address account, bytes32 ownerId) external view returns (OwnerConfig memory) {
@@ -301,11 +307,9 @@ contract AccountConfiguration is IAccountConfiguration {
     }
 
     function _authorizeOwner(address account, bytes32 ownerId, OwnerConfig memory config) internal nonZero(account) {
-        // Must be legitimate verifier
-        require(config.verifier != address(0));
-
-        // Must not already be registered
-        require(_ownerConfig[ownerId][account].verifier == address(0));
+        require(config.verifier > REVOKED_VERIFIER);
+        address existing = _ownerConfig[ownerId][account].verifier;
+        require(existing == address(0) || existing == REVOKED_VERIFIER);
 
         _ownerConfig[ownerId][account] = config;
         emit OwnerAuthorized(account, ownerId, config);
@@ -314,8 +318,7 @@ contract AccountConfiguration is IAccountConfiguration {
     function _revokeOwner(address account, bytes32 ownerId) internal nonZero(account) {
         require(isOwner(account, ownerId));
         if (ownerId == bytes32(bytes20(account))) {
-            // Self-ownerId: sentinel prevents protocol implicit re-authorization on empty slot
-            _ownerConfig[ownerId][account] = OwnerConfig({verifier: address(0), scopes: type(uint8).max});
+            _ownerConfig[ownerId][account] = OwnerConfig({verifier: REVOKED_VERIFIER, scopes: 0});
         } else {
             delete _ownerConfig[ownerId][account];
         }
@@ -369,6 +372,8 @@ contract AccountConfiguration is IAccountConfiguration {
         view
         returns (uint8 scopes)
     {
+        if (verifier == address(0)) return _verifyImplicitEOA(account, hash, data);
+
         bytes32 ownerId = IVerifier(verifier).verify(hash, data);
         require(ownerId != bytes32(0));
 
@@ -377,6 +382,17 @@ contract AccountConfiguration is IAccountConfiguration {
         return config.scopes;
     }
 
+    /// @dev Implicit EOA: native ecrecover, requires self-ownerId slot is empty (not REVOKED_VERIFIER).
+    function _verifyImplicitEOA(address account, bytes32 hash, bytes calldata data) internal view returns (uint8) {
+        require(_ownerConfig[bytes32(bytes20(account))][account].verifier == address(0));
+        require(data.length == 65);
+        bytes32 r = bytes32(data[:32]);
+        bytes32 s = bytes32(data[32:64]);
+        address recovered = ecrecover(hash, uint8(data[64]), r, s);
+        require(recovered == account);
+        return 0;
+    }
+
     // ----------------------------------------------------------------------------------------------------------------
     // ACCOUNT CREATION
     // ----------------------------------------------------------------------------------------------------------------
diff --git a/test/lib/AccountConfigurationTest.sol b/test/lib/AccountConfigurationTest.sol
@@ -78,6 +78,12 @@ contract AccountConfigurationTest is Test {
         return abi.encodePacked(address(k1Verifier), sig);
     }
 
+    /// @dev Build auth bytes for implicit EOA path: address(0) || ecdsa signature.
+    function _buildImplicitEOAAuth(uint256 pk, bytes32 digest) internal pure returns (bytes memory) {
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(pk, digest);
+        return abi.encodePacked(address(0), r, s, v);
+    }
+
     // ── Canonical digest computation ──
 
     function _computeOwnerChangeBatchDigest(
diff --git a/test/unit/AccountConfiguration/applyKeyChange.t.sol b/test/unit/AccountConfiguration/applyKeyChange.t.sol
@@ -262,12 +262,92 @@ contract ApplyConfigChangeOwnerTest is AccountConfigurationTest {
         accountConfiguration.applySignedOwnerChanges(account, uint64(block.chainid), changes, badAuth);
     }
 
-    // ── EOA self-ownerId (default key) revoke/add ──
+    // ── Implicit EOA (registered by default) ──
+    //
+    // Every account has an implicit self-ownerId bytes32(bytes20(account))
+    // that is authorized with unrestricted scopes when the config slot
+    // is empty. No createAccount/importAccount needed.
+
+    function test_implicitEOA_canSignOwnerChanges() public {
+        uint256 eoaPk = 500;
+        address eoa = vm.addr(eoaPk);
+        bytes32 newOwnerId = bytes32(bytes20(vm.addr(501)));
+
+        IAccountConfiguration.OwnerChange[] memory changes = new IAccountConfiguration.OwnerChange[](1);
+        changes[0] = IAccountConfiguration.OwnerChange({
+            ownerId: newOwnerId,
+            changeType: 0x01,
+            configData: abi.encode(IAccountConfiguration.OwnerConfig({verifier: address(k1Verifier), scopes: 0x00}))
+        });
+
+        uint64 seq = accountConfiguration.getChangeSequences(eoa).local;
+        bytes32 digest = _computeOwnerChangeBatchDigest(eoa, uint64(block.chainid), seq, changes);
+        bytes memory auth = _buildImplicitEOAAuth(eoaPk, digest);
+
+        accountConfiguration.applySignedOwnerChanges(eoa, uint64(block.chainid), changes, auth);
+        assertTrue(accountConfiguration.isOwner(eoa, newOwnerId));
+    }
+
+    function test_implicitEOA_canRevokeItselfViaSentinel() public {
+        uint256 eoaPk = 500;
+        address eoa = vm.addr(eoaPk);
+        bytes32 selfOwnerId = bytes32(bytes20(eoa));
+
+        assertTrue(accountConfiguration.isOwner(eoa, selfOwnerId));
+
+        // Add a second key first using implicit EOA auth
+        bytes32 newOwnerId = bytes32(bytes20(vm.addr(501)));
+        _implicitAuthorizeOwner(eoa, eoaPk, newOwnerId, address(k1Verifier));
+
+        // Revoke self-ownerId using the new explicit key
+        _revokeOwner(eoa, 501, selfOwnerId);
+
+        assertFalse(accountConfiguration.isOwner(eoa, selfOwnerId));
+        assertTrue(accountConfiguration.isOwner(eoa, newOwnerId));
+
+        IAccountConfiguration.OwnerConfig memory cfg = accountConfiguration.getOwnerConfig(eoa, selfOwnerId);
+        assertEq(cfg.verifier, accountConfiguration.REVOKED_VERIFIER());
+        assertEq(cfg.scopes, 0);
+    }
+
+    function test_implicitEOA_canBeExplicitlyRegistered() public {
+        uint256 eoaPk = 500;
+        address eoa = vm.addr(eoaPk);
+        bytes32 selfOwnerId = bytes32(bytes20(eoa));
+
+        _implicitAuthorizeOwnerWithScope(eoa, eoaPk, selfOwnerId, address(k1Verifier), 0x01);
+
+        IAccountConfiguration.OwnerConfig memory cfg = accountConfiguration.getOwnerConfig(eoa, selfOwnerId);
+        assertEq(cfg.verifier, address(k1Verifier));
+        assertEq(cfg.scopes, 0x01);
+    }
+
+    function test_implicitEOA_crossChainOwnerChange() public {
+        uint256 eoaPk = 500;
+        address eoa = vm.addr(eoaPk);
+        bytes32 newOwnerId = bytes32(bytes20(vm.addr(501)));
+
+        IAccountConfiguration.OwnerChange[] memory changes = new IAccountConfiguration.OwnerChange[](1);
+        changes[0] = IAccountConfiguration.OwnerChange({
+            ownerId: newOwnerId,
+            changeType: 0x01,
+            configData: abi.encode(IAccountConfiguration.OwnerConfig({verifier: address(k1Verifier), scopes: 0x00}))
+        });
+
+        // chainId=0 for multichain
+        uint64 seq = accountConfiguration.getChangeSequences(eoa).multichain;
+        bytes32 digest = _computeOwnerChangeBatchDigest(eoa, 0, seq, changes);
+        bytes memory auth = _buildImplicitEOAAuth(eoaPk, digest);
+
+        accountConfiguration.applySignedOwnerChanges(eoa, 0, changes, auth);
+        assertTrue(accountConfiguration.isOwner(eoa, newOwnerId));
+    }
+
+    // ── EOA self-ownerId revoke/add with explicit registration ──
     //
     // The self-ownerId for an account is bytes32(bytes20(account)).
     // Revoking this ownerId sets a sentinel (verifier=0, scopes=0xff)
-    // instead of deleting, to prevent the 8130 protocol's implicit
-    // re-authorization on an empty slot.
+    // instead of deleting, to block the implicit authorization.
 
     function test_selfOwnerId_addKey() public {
         (address account,) = _createK1Account(OWNER_PK);
@@ -289,8 +369,8 @@ contract ApplyConfigChangeOwnerTest is AccountConfigurationTest {
         assertFalse(accountConfiguration.isOwner(account, selfOwnerId));
 
         IAccountConfiguration.OwnerConfig memory cfg = accountConfiguration.getOwnerConfig(account, selfOwnerId);
-        assertEq(cfg.verifier, address(0));
-        assertEq(cfg.scopes, type(uint8).max);
+        assertEq(cfg.verifier, accountConfiguration.REVOKED_VERIFIER());
+        assertEq(cfg.scopes, 0);
     }
 
     function test_selfOwnerId_canReauthorizeAfterSentinel() public {
@@ -334,8 +414,8 @@ contract ApplyConfigChangeOwnerTest is AccountConfigurationTest {
 
         // Self-ownerId has sentinel, not zeroed
         IAccountConfiguration.OwnerConfig memory cfg = accountConfiguration.getOwnerConfig(account, selfOwnerId);
-        assertEq(cfg.verifier, address(0));
-        assertEq(cfg.scopes, type(uint8).max);
+        assertEq(cfg.verifier, accountConfiguration.REVOKED_VERIFIER());
+        assertEq(cfg.scopes, 0);
     }
 
     function test_selfOwnerId_revokedCannotSignOwnerChanges() public {
@@ -442,6 +522,31 @@ contract ApplyConfigChangeOwnerTest is AccountConfigurationTest {
         accountConfiguration.applySignedOwnerChanges(account, uint64(block.chainid), changes, auth);
     }
 
+    function _implicitAuthorizeOwner(address account, uint256 pk, bytes32 newOwnerId, address verifier) internal {
+        _implicitAuthorizeOwnerWithScope(account, pk, newOwnerId, verifier, 0x00);
+    }
+
+    function _implicitAuthorizeOwnerWithScope(
+        address account,
+        uint256 pk,
+        bytes32 newOwnerId,
+        address verifier,
+        uint8 scope
+    ) internal {
+        IAccountConfiguration.OwnerChange[] memory changes = new IAccountConfiguration.OwnerChange[](1);
+        changes[0] = IAccountConfiguration.OwnerChange({
+            ownerId: newOwnerId,
+            changeType: 0x01,
+            configData: abi.encode(IAccountConfiguration.OwnerConfig({verifier: verifier, scopes: scope}))
+        });
+
+        uint64 seq = accountConfiguration.getChangeSequences(account).local;
+        bytes32 digest = _computeOwnerChangeBatchDigest(account, uint64(block.chainid), seq, changes);
+        bytes memory auth = _buildImplicitEOAAuth(pk, digest);
+
+        accountConfiguration.applySignedOwnerChanges(account, uint64(block.chainid), changes, auth);
+    }
+
     function _lockAccount(address account) internal {
         vm.prank(account);
         accountConfiguration.lock(1 hours);
diff --git a/test/unit/AccountConfiguration/verify.t.sol b/test/unit/AccountConfiguration/verify.t.sol
@@ -115,6 +115,56 @@ contract VerifyTest is AccountConfigurationTest {
         assertEq(scopes, uint8(0x00));
     }
 
+    // ── Implicit EOA (registered by default) ──
+
+    function test_verify_implicitEOA() public {
+        uint256 eoaPk = 500;
+        address eoa = vm.addr(eoaPk);
+
+        bytes32 hash = keccak256("implicit eoa verify");
+        bytes memory auth = _buildImplicitEOAAuth(eoaPk, hash);
+
+        // No createAccount or importAccount — the EOA is implicitly authorized
+        uint8 scopes = accountConfiguration.verify(eoa, hash, auth);
+        assertEq(scopes, 0);
+    }
+
+    function test_verify_implicitEOA_isOwnerReturnsTrue() public {
+        uint256 eoaPk = 500;
+        address eoa = vm.addr(eoaPk);
+
+        assertTrue(accountConfiguration.isOwner(eoa, bytes32(bytes20(eoa))));
+    }
+
+    function test_verify_implicitEOA_nonSelfOwnerIdNotImplicit() public {
+        uint256 eoaPk = 500;
+        address eoa = vm.addr(eoaPk);
+
+        // A random ownerId that isn't bytes32(bytes20(eoa)) should NOT be implicit
+        bytes32 randomOwnerId = bytes32(bytes20(vm.addr(999)));
+        assertFalse(accountConfiguration.isOwner(eoa, randomOwnerId));
+    }
+
+    function test_verify_implicitEOA_revokedBySentinel() public {
+        uint256 eoaPk = 500;
+        address eoa = vm.addr(eoaPk);
+        bytes32 selfOwnerId = bytes32(bytes20(eoa));
+
+        // Implicit EOA signs to add a second key
+        bytes32 newOwnerId = bytes32(bytes20(vm.addr(501)));
+        _implicitAuthorizeOwner(eoa, eoaPk, newOwnerId, address(k1Verifier));
+
+        // Revoke the self-ownerId (writes sentinel) using the new explicit key
+        _revokeOwner(eoa, 501, selfOwnerId);
+
+        assertFalse(accountConfiguration.isOwner(eoa, selfOwnerId));
+
+        // Implicit path is now blocked
+        bytes32 hash = keccak256("after sentinel");
+        vm.expectRevert();
+        accountConfiguration.verify(eoa, hash, _buildImplicitEOAAuth(eoaPk, hash));
+    }
+
     // ── Helpers ──
 
     function _authorizeOwner(address account, uint256 pk, bytes32 newOwnerId, address verifier) internal {
@@ -148,4 +198,19 @@ contract VerifyTest is AccountConfigurationTest {
 
         accountConfiguration.applySignedOwnerChanges(account, uint64(block.chainid), changes, auth);
     }
+
+    function _implicitAuthorizeOwner(address account, uint256 pk, bytes32 newOwnerId, address verifier) internal {
+        IAccountConfiguration.OwnerChange[] memory changes = new IAccountConfiguration.OwnerChange[](1);
+        changes[0] = IAccountConfiguration.OwnerChange({
+            ownerId: newOwnerId,
+            changeType: 0x01,
+            configData: abi.encode(IAccountConfiguration.OwnerConfig({verifier: verifier, scopes: 0x00}))
+        });
+
+        uint64 seq = accountConfiguration.getChangeSequences(account).local;
+        bytes32 digest = _computeOwnerChangeBatchDigest(account, uint64(block.chainid), seq, changes);
+        bytes memory auth = _buildImplicitEOAAuth(pk, digest);
+
+        accountConfiguration.applySignedOwnerChanges(account, uint64(block.chainid), changes, auth);
+    }
 }
