社会恢复 + 企业 IAM — 实现

For Claude: REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.

Goal: Extend the BabyDriver DID system with social recovery (N-of-M guardians + timelock), enterprise IAM (organizations + roles + permission bitmaps), and selective disclosure (ZK-based attribute-level verification).

Architecture: Extend DIDRegistry (0x8017) with recovery logic, extend IdentityVerifier (0x8019) with disclosure policies, and create new EnterpriseIAM system contract (0x801A). Each has a Local test variant for Foundry testing. All L1-sync via L1Messenger.

Tech Stack: Solidity ^0.8.26/^0.8.28, Foundry (forge test), zksync system contracts, L1Messenger

Design doc: docs/plans/2026-03-06-phase5c-design.md

---

Key Paths

Alias	Path
CONTRACTS	/Users/judybaby/CodeBase/github/Layer2/contracts
SYS	/Users/judybaby/CodeBase/github/Layer2/era-contracts-l1/system-contracts/contracts
TEST	/Users/judybaby/CodeBase/github/Layer2/contracts/test
DID_SRC	/Users/judybaby/CodeBase/github/Layer2/contracts/src/did

Existing Files Reference

Interfaces (system contract):

• SYS/interfaces/IDIDRegistry.sol — 36 lines, struct DIDDocument, 5 events, 9 functions

• SYS/interfaces/IIdentityVerifier.sol — 53 lines, enum VerificationMode, 6 events, 14 functions

Implementations (system contract):

• SYS/DIDRegistry.sol — 180 lines, uses onlySystemCall, L1Messenger sync

• SYS/IdentityVerifier.sol — 299 lines, uses onlySystemCall, Groth16 dispatch

Local test variants:

• DID_SRC/IDIDRegistryLocal.sol — 30 lines, mirrors IDIDRegistry without system deps

• DID_SRC/DIDRegistryLocal.sol — 111 lines, no onlySystemCall, no L1Messenger

• DID_SRC/IdentityVerifierLocal.sol — 217 lines, constructor(didReg, credReg, admin)

• DID_SRC/CredentialRegistryLocal.sol — 103 lines, constructor(didReg)

Constants:

• SYS/Constants.sol:111-121 — BabyDriver system contracts 0x8016-0x8019

• New 0x801A goes after line 121

Test pattern (from TEST/DIDRegistry.t.sol):

import "forge-std/Test.sol";
import "../src/did/DIDRegistryLocal.sol";
// setUp(): registry = new DIDRegistryLocal();
// helpers: _createDID(user) with vm.prank
// vm.expectRevert, vm.expectEmit, vm.warp for time

---

Task 1: IDIDRegistryLocal — Add Recovery Interface

Files:

• Modify: DID_SRC/IDIDRegistryLocal.sol:1-30

Step 1: Add recovery events and functions to the interface

Open contracts/src/did/IDIDRegistryLocal.sol and append the following after line 19 (after DelegateRevoked event) and before line 21 (before createDID function):

    // ── Social Recovery Events ────────────────────────────────
    event RecoveryConfigured(address indexed identity, uint8 threshold, uint8 guardianCount);
    event RecoveryInitiated(address indexed identity, address indexed newController, address indexed initiator);
    event RecoveryApproved(address indexed identity, address indexed guardian, uint8 approvalCount);
    event RecoveryExecuted(address indexed identity, address indexed oldController, address indexed newController);
    event RecoveryCancelled(address indexed identity);

And append the following after line 29 (after getNonce function), before the closing }:

    // ── Social Recovery ──────────────────────────────────────
    function setRecovery(address[] calldata guardians, uint8 threshold, uint64 timelockDuration) external;
    function initiateRecovery(address identity, address newController) external;
    function approveRecovery(address identity) external;
    function executeRecovery(address identity) external;
    function cancelRecovery() external;
    function getRecoveryConfig(address identity) external view returns (address[] memory guardians, uint8 threshold, uint64 timelockDuration);
    function getRecoveryRequest(address identity) external view returns (address newController, uint64 initiatedAt, uint8 approvalCount, bool executable);

Step 2: Verify it compiles

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge build Expected: Compilation warnings about unimplemented functions (DIDRegistryLocal doesn't yet implement the new functions) — this is correct, the interface compiles.

Step 3: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add contracts/src/did/IDIDRegistryLocal.sol
git commit -m "feat(did): add social recovery interface to IDIDRegistryLocal"

---

Task 2: DIDRegistryLocal — Implement Social Recovery

Files:

• Modify: DID_SRC/DIDRegistryLocal.sol:1-111

Step 1: Add recovery storage and errors after existing errors (line 20)

After the existing error declarations (line 20 EmptyVerificationMethods), add:

    error RecoveryNotConfigured(address identity);
    error RecoveryAlreadyPending(address identity);
    error RecoveryNotPending(address identity);
    error NotGuardian(address caller);
    error AlreadyApproved(address guardian);
    error RecoveryNotExecutable();
    error InvalidRecoveryConfig();
    error GuardianIsSelf(address identity);
    error DuplicateGuardian(address guardian);
    error TimelockTooShort();

Step 2: Add recovery structs and storage after _nonces mapping (line 12)

After line 12 (mapping(address => uint256) private _nonces;), add:

    // ── Recovery Storage ─────────────────────────────────────
    struct RecoveryConfig {
        address[] guardians;
        uint8 threshold;
        uint64 timelockDuration;
    }

    struct RecoveryRequestData {
        address newController;
        uint64 initiatedAt;
        uint8 approvalCount;
    }

    mapping(address => RecoveryConfig) private _recoveryConfigs;
    mapping(address => RecoveryRequestData) private _recoveryRequests;
    mapping(address => mapping(address => bool)) private _recoveryApprovals;
    // identity => guardian => hasApproved

Step 3: Add recovery implementation functions before the closing }

Append these functions at the end of the contract (before closing }):

    // ── Social Recovery ──────────────────────────────────────

    function setRecovery(
        address[] calldata guardians,
        uint8 threshold,
        uint64 timelockDuration
    ) external override onlyController(msg.sender) {
        if (!_documents[msg.sender].active) revert DIDNotActive(msg.sender);
        if (threshold == 0 || threshold > guardians.length || guardians.length > 7) revert InvalidRecoveryConfig();
        if (timelockDuration < 1 hours) revert TimelockTooShort();

        // Validate guardians
        for (uint256 i = 0; i < guardians.length; i++) {
            if (guardians[i] == msg.sender) revert GuardianIsSelf(msg.sender);
            for (uint256 j = i + 1; j < guardians.length; j++) {
                if (guardians[i] == guardians[j]) revert DuplicateGuardian(guardians[i]);
            }
        }

        _recoveryConfigs[msg.sender] = RecoveryConfig({
            guardians: guardians,
            threshold: threshold,
            timelockDuration: timelockDuration
        });

        // Clear any pending recovery when guardians change
        _clearRecoveryRequest(msg.sender);

        emit RecoveryConfigured(msg.sender, threshold, uint8(guardians.length));
    }

    function initiateRecovery(
        address identity,
        address newController
    ) external override {
        RecoveryConfig storage config = _recoveryConfigs[identity];
        if (config.guardians.length == 0) revert RecoveryNotConfigured(identity);
        if (_recoveryRequests[identity].initiatedAt != 0) revert RecoveryAlreadyPending(identity);
        if (!_isGuardian(identity, msg.sender)) revert NotGuardian(msg.sender);
        if (newController == address(0)) revert InvalidRecoveryConfig();

        _recoveryRequests[identity] = RecoveryRequestData({
            newController: newController,
            initiatedAt: uint64(block.timestamp),
            approvalCount: 1
        });
        _recoveryApprovals[identity][msg.sender] = true;

        emit RecoveryInitiated(identity, newController, msg.sender);
    }

    function approveRecovery(address identity) external override {
        if (_recoveryRequests[identity].initiatedAt == 0) revert RecoveryNotPending(identity);
        if (!_isGuardian(identity, msg.sender)) revert NotGuardian(msg.sender);
        if (_recoveryApprovals[identity][msg.sender]) revert AlreadyApproved(msg.sender);

        _recoveryApprovals[identity][msg.sender] = true;
        _recoveryRequests[identity].approvalCount++;

        emit RecoveryApproved(identity, msg.sender, _recoveryRequests[identity].approvalCount);
    }

    function executeRecovery(address identity) external override {
        RecoveryRequestData storage req = _recoveryRequests[identity];
        RecoveryConfig storage config = _recoveryConfigs[identity];
        if (req.initiatedAt == 0) revert RecoveryNotPending(identity);
        if (req.approvalCount < config.threshold) revert RecoveryNotExecutable();
        if (block.timestamp < req.initiatedAt + config.timelockDuration) revert RecoveryNotExecutable();

        address oldController = _documents[identity].controller;
        address newController = req.newController;

        _documents[identity].controller = newController;
        _documents[identity].updated = uint64(block.timestamp);
        _nonces[identity]++;

        _clearRecoveryRequest(identity);

        emit RecoveryExecuted(identity, oldController, newController);
    }

    function cancelRecovery() external override onlyController(msg.sender) {
        if (_recoveryRequests[msg.sender].initiatedAt == 0) revert RecoveryNotPending(msg.sender);
        _clearRecoveryRequest(msg.sender);
        emit RecoveryCancelled(msg.sender);
    }

    function getRecoveryConfig(address identity) external view override returns (
        address[] memory guardians, uint8 threshold, uint64 timelockDuration
    ) {
        RecoveryConfig storage config = _recoveryConfigs[identity];
        return (config.guardians, config.threshold, config.timelockDuration);
    }

    function getRecoveryRequest(address identity) external view override returns (
        address newController, uint64 initiatedAt, uint8 approvalCount, bool executable
    ) {
        RecoveryRequestData storage req = _recoveryRequests[identity];
        RecoveryConfig storage config = _recoveryConfigs[identity];
        bool exec = req.initiatedAt != 0
            && req.approvalCount >= config.threshold
            && block.timestamp >= req.initiatedAt + config.timelockDuration;
        return (req.newController, req.initiatedAt, req.approvalCount, exec);
    }

    // ── Recovery Helpers ─────────────────────────────────────

    function _isGuardian(address identity, address account) internal view returns (bool) {
        RecoveryConfig storage config = _recoveryConfigs[identity];
        for (uint256 i = 0; i < config.guardians.length; i++) {
            if (config.guardians[i] == account) return true;
        }
        return false;
    }

    function _clearRecoveryRequest(address identity) internal {
        RecoveryConfig storage config = _recoveryConfigs[identity];
        for (uint256 i = 0; i < config.guardians.length; i++) {
            _recoveryApprovals[identity][config.guardians[i]] = false;
        }
        delete _recoveryRequests[identity];
    }

Step 4: Verify compilation

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge build Expected: Compiles clean

Step 5: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add contracts/src/did/DIDRegistryLocal.sol
git commit -m "feat(did): implement social recovery in DIDRegistryLocal"

---

Task 3: Social Recovery Tests

Files:

• Create: TEST/DIDRegistryRecovery.t.sol

Step 1: Write the test file

Create contracts/test/DIDRegistryRecovery.t.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

import "forge-std/Test.sol";
import "../src/did/DIDRegistryLocal.sol";

contract DIDRegistryRecoveryTest is Test {
    DIDRegistryLocal public registry;

    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    address charlie = makeAddr("charlie");
    address dave = makeAddr("dave");
    address eve = makeAddr("eve");
    address newOwner = makeAddr("newOwner");

    bytes32 key1 = keccak256("pubkey_1");
    bytes32 serviceHash = keccak256("service");

    function setUp() public {
        registry = new DIDRegistryLocal();
        _createDID(alice);
    }

    function _createDID(address user) internal {
        bytes32[] memory methods = new bytes32[](1);
        methods[0] = keccak256(abi.encodePacked("pubkey_", user));
        vm.prank(user);
        registry.createDID(methods, serviceHash);
    }

    function _setRecovery2of3(address user) internal {
        address[] memory guardians = new address[](3);
        guardians[0] = bob;
        guardians[1] = charlie;
        guardians[2] = dave;
        vm.prank(user);
        registry.setRecovery(guardians, 2, 1 days);
    }

    // ── setRecovery ──────────────────────────────────────────

    function test_setRecovery_success() public {
        _setRecovery2of3(alice);
        (address[] memory guardians, uint8 threshold, uint64 timelock) = registry.getRecoveryConfig(alice);
        assertEq(guardians.length, 3);
        assertEq(guardians[0], bob);
        assertEq(threshold, 2);
        assertEq(timelock, 1 days);
    }

    function test_setRecovery_emitsEvent() public {
        address[] memory guardians = new address[](2);
        guardians[0] = bob;
        guardians[1] = charlie;
        vm.expectEmit(true, false, false, true);
        emit IDIDRegistryLocal.RecoveryConfigured(alice, 2, 2);
        vm.prank(alice);
        registry.setRecovery(guardians, 2, 1 days);
    }

    function test_setRecovery_revert_notController() public {
        address[] memory guardians = new address[](1);
        guardians[0] = bob;
        vm.prank(bob);
        vm.expectRevert();
        registry.setRecovery(guardians, 1, 1 days);
    }

    function test_setRecovery_revert_thresholdZero() public {
        address[] memory guardians = new address[](1);
        guardians[0] = bob;
        vm.prank(alice);
        vm.expectRevert();
        registry.setRecovery(guardians, 0, 1 days);
    }

    function test_setRecovery_revert_thresholdExceedsGuardians() public {
        address[] memory guardians = new address[](1);
        guardians[0] = bob;
        vm.prank(alice);
        vm.expectRevert();
        registry.setRecovery(guardians, 2, 1 days);
    }

    function test_setRecovery_revert_tooManyGuardians() public {
        address[] memory guardians = new address[](8);
        for (uint i = 0; i < 8; i++) {
            guardians[i] = address(uint160(100 + i));
        }
        vm.prank(alice);
        vm.expectRevert();
        registry.setRecovery(guardians, 1, 1 days);
    }

    function test_setRecovery_revert_selfGuardian() public {
        address[] memory guardians = new address[](1);
        guardians[0] = alice;
        vm.prank(alice);
        vm.expectRevert();
        registry.setRecovery(guardians, 1, 1 days);
    }

    function test_setRecovery_revert_duplicateGuardian() public {
        address[] memory guardians = new address[](2);
        guardians[0] = bob;
        guardians[1] = bob;
        vm.prank(alice);
        vm.expectRevert();
        registry.setRecovery(guardians, 1, 1 days);
    }

    function test_setRecovery_revert_timelockTooShort() public {
        address[] memory guardians = new address[](1);
        guardians[0] = bob;
        vm.prank(alice);
        vm.expectRevert();
        registry.setRecovery(guardians, 1, 30 minutes);
    }

    function test_setRecovery_clearsPendingRequest() public {
        _setRecovery2of3(alice);
        // Initiate a recovery
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        // Reconfigure clears the pending request
        _setRecovery2of3(alice);
        (, uint64 initiatedAt,,) = registry.getRecoveryRequest(alice);
        assertEq(initiatedAt, 0);
    }

    // ── initiateRecovery ────────────────────────────────────

    function test_initiateRecovery_success() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);

        (address nc, uint64 at, uint8 count, bool exec) = registry.getRecoveryRequest(alice);
        assertEq(nc, newOwner);
        assertGt(at, 0);
        assertEq(count, 1);
        assertFalse(exec);
    }

    function test_initiateRecovery_emitsEvent() public {
        _setRecovery2of3(alice);
        vm.expectEmit(true, true, true, true);
        emit IDIDRegistryLocal.RecoveryInitiated(alice, newOwner, bob);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
    }

    function test_initiateRecovery_revert_notGuardian() public {
        _setRecovery2of3(alice);
        vm.prank(eve);
        vm.expectRevert();
        registry.initiateRecovery(alice, newOwner);
    }

    function test_initiateRecovery_revert_noConfig() public {
        vm.prank(bob);
        vm.expectRevert();
        registry.initiateRecovery(alice, newOwner);
    }

    function test_initiateRecovery_revert_alreadyPending() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        vm.prank(charlie);
        vm.expectRevert();
        registry.initiateRecovery(alice, newOwner);
    }

    // ── approveRecovery ─────────────────────────────────────

    function test_approveRecovery_success() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        vm.prank(charlie);
        registry.approveRecovery(alice);

        (,, uint8 count,) = registry.getRecoveryRequest(alice);
        assertEq(count, 2);
    }

    function test_approveRecovery_emitsEvent() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        vm.expectEmit(true, true, false, true);
        emit IDIDRegistryLocal.RecoveryApproved(alice, charlie, 2);
        vm.prank(charlie);
        registry.approveRecovery(alice);
    }

    function test_approveRecovery_revert_notGuardian() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        vm.prank(eve);
        vm.expectRevert();
        registry.approveRecovery(alice);
    }

    function test_approveRecovery_revert_alreadyApproved() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        vm.prank(bob);
        vm.expectRevert();
        registry.approveRecovery(alice);
    }

    // ── executeRecovery ──────────────────────────────────────

    function test_executeRecovery_success() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        vm.prank(charlie);
        registry.approveRecovery(alice);

        // Warp past timelock
        vm.warp(block.timestamp + 1 days + 1);
        registry.executeRecovery(alice);

        IDIDRegistryLocal.DIDDocument memory doc = registry.resolveDID(alice);
        assertEq(doc.controller, newOwner);
    }

    function test_executeRecovery_emitsEvent() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        vm.prank(charlie);
        registry.approveRecovery(alice);
        vm.warp(block.timestamp + 1 days + 1);

        vm.expectEmit(true, true, true, true);
        emit IDIDRegistryLocal.RecoveryExecuted(alice, alice, newOwner);
        registry.executeRecovery(alice);
    }

    function test_executeRecovery_revert_timelockNotExpired() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        vm.prank(charlie);
        registry.approveRecovery(alice);
        // Don't warp — timelock not expired
        vm.expectRevert();
        registry.executeRecovery(alice);
    }

    function test_executeRecovery_revert_thresholdNotMet() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        // Only 1 of 2 approvals
        vm.warp(block.timestamp + 1 days + 1);
        vm.expectRevert();
        registry.executeRecovery(alice);
    }

    function test_executeRecovery_clearsRequest() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        vm.prank(charlie);
        registry.approveRecovery(alice);
        vm.warp(block.timestamp + 1 days + 1);
        registry.executeRecovery(alice);

        (, uint64 at,,) = registry.getRecoveryRequest(alice);
        assertEq(at, 0);
    }

    // ── cancelRecovery ───────────────────────────────────────

    function test_cancelRecovery_success() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);

        vm.prank(alice);
        registry.cancelRecovery();

        (, uint64 at,,) = registry.getRecoveryRequest(alice);
        assertEq(at, 0);
    }

    function test_cancelRecovery_emitsEvent() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        vm.expectEmit(true, false, false, true);
        emit IDIDRegistryLocal.RecoveryCancelled(alice);
        vm.prank(alice);
        registry.cancelRecovery();
    }

    function test_cancelRecovery_revert_notController() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        vm.prank(bob);
        vm.expectRevert();
        registry.cancelRecovery();
    }

    function test_cancelRecovery_revert_noPending() public {
        _setRecovery2of3(alice);
        vm.prank(alice);
        vm.expectRevert();
        registry.cancelRecovery();
    }

    // ── Edge Cases ───────────────────────────────────────────

    function test_executeRecovery_1of1() public {
        address[] memory guardians = new address[](1);
        guardians[0] = bob;
        vm.prank(alice);
        registry.setRecovery(guardians, 1, 1 hours);

        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        vm.warp(block.timestamp + 1 hours + 1);
        registry.executeRecovery(alice);

        assertEq(registry.resolveDID(alice).controller, newOwner);
    }

    function test_newController_canManageDID() public {
        _setRecovery2of3(alice);
        vm.prank(bob);
        registry.initiateRecovery(alice, newOwner);
        vm.prank(charlie);
        registry.approveRecovery(alice);
        vm.warp(block.timestamp + 1 days + 1);
        registry.executeRecovery(alice);

        // newOwner can now update the DID
        bytes32[] memory methods = new bytes32[](1);
        methods[0] = keccak256("new_key");
        vm.prank(newOwner);
        registry.updateDocument(methods, keccak256("new_service"));
        assertEq(registry.resolveDID(alice).controller, newOwner);
    }
}

Step 2: Run tests to verify they pass

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test --match-contract DIDRegistryRecoveryTest -v Expected: All tests pass (20 tests)

Step 3: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add contracts/test/DIDRegistryRecovery.t.sol
git commit -m "test(did): add 20 social recovery tests for DIDRegistryLocal"

---

Task 4: IEnterpriseIAM Interface + EnterpriseIAMLocal Contract

Files:

• Create: DID_SRC/IEnterpriseIAMLocal.sol

• Create: DID_SRC/EnterpriseIAMLocal.sol

Step 1: Create the interface

Create contracts/src/did/IEnterpriseIAMLocal.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

/// @dev Local test interface for EnterpriseIAM system contract.
interface IEnterpriseIAMLocal {
    // ── Events ───────────────────────────────────────────────
    event OrganizationCreated(bytes32 indexed orgId, address indexed orgDID, address indexed owner);
    event OrganizationDeactivated(bytes32 indexed orgId);
    event RoleCreated(bytes32 indexed orgId, uint256 indexed roleId, bytes32 name, uint256 permissions);
    event RoleAssigned(bytes32 indexed orgId, address indexed member, uint256 indexed roleId);
    event RoleRevoked(bytes32 indexed orgId, address indexed member);

    // ── Organization Management ──────────────────────────────
    function createOrganization(bytes32 orgId, address orgDID) external;
    function deactivateOrganization(bytes32 orgId) external;
    function getOrganization(bytes32 orgId) external view returns (address orgDID, address owner, uint256 memberCount, bool active);

    // ── Role Management ──────────────────────────────────────
    function createRole(bytes32 orgId, bytes32 name, uint256 permissions) external returns (uint256 roleId);
    function getRole(bytes32 orgId, uint256 roleId) external view returns (bytes32 name, uint256 permissions, address admin);

    // ── Member Management ────────────────────────────────────
    function assignRole(bytes32 orgId, address member, uint256 roleId) external;
    function revokeRole(bytes32 orgId, address member) external;
    function getMemberRole(bytes32 orgId, address member) external view returns (uint256);
    function hasPermission(bytes32 orgId, address member, uint256 permission) external view returns (bool);
}

Step 2: Create the implementation

Create contracts/src/did/EnterpriseIAMLocal.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

import {IEnterpriseIAMLocal} from "./IEnterpriseIAMLocal.sol";
import {IDIDRegistryLocal} from "./IDIDRegistryLocal.sol";

/// @dev Local Foundry-testable version of EnterpriseIAM system contract.
contract EnterpriseIAMLocal is IEnterpriseIAMLocal {
    // ── Permission Constants ─────────────────────────────────
    uint256 public constant PERM_ISSUE_CREDENTIAL   = 1 << 0;
    uint256 public constant PERM_REVOKE_CREDENTIAL  = 1 << 1;
    uint256 public constant PERM_MANAGE_MEMBERS     = 1 << 2;
    uint256 public constant PERM_MANAGE_ROLES       = 1 << 3;
    uint256 public constant PERM_VIEW_REPORTS       = 1 << 4;
    uint256 public constant PERM_MANAGE_COMPLIANCE  = 1 << 5;
    uint256 public constant PERM_ADMIN              = 1 << 6;
    uint256 public constant PERM_SIGN_TRANSACTIONS  = 1 << 7;

    // ── Storage ──────────────────────────────────────────────
    struct OrganizationData {
        address orgDID;
        address owner;
        uint256 memberCount;
        bool active;
    }

    struct RoleData {
        bytes32 name;
        uint256 permissions;
        address admin;
    }

    IDIDRegistryLocal public didRegistry;

    mapping(bytes32 => OrganizationData) private _organizations;
    mapping(bytes32 => mapping(uint256 => RoleData)) private _roles;
    mapping(bytes32 => mapping(address => uint256)) private _memberRoles;
    mapping(bytes32 => uint256) private _roleCounter;

    // ── Errors ───────────────────────────────────────────────
    error OrgAlreadyExists(bytes32 orgId);
    error OrgNotFound(bytes32 orgId);
    error OrgNotActive(bytes32 orgId);
    error NotOrgOwner(address caller);
    error InsufficientPermission(address caller, uint256 required);
    error DIDNotActive(address orgDID);
    error NotControllerOrDelegate(address caller, address orgDID);
    error RoleNotFound(bytes32 orgId, uint256 roleId);
    error MemberAlreadyAssigned(bytes32 orgId, address member);
    error MemberNotAssigned(bytes32 orgId, address member);
    error InvalidPermissions();

    // ── Constructor ──────────────────────────────────────────
    constructor(address _didRegistry) {
        didRegistry = IDIDRegistryLocal(_didRegistry);
    }

    // ── Modifiers ────────────────────────────────────────────
    modifier onlyOrgOwnerOrPermission(bytes32 orgId, uint256 perm) {
        OrganizationData storage org = _organizations[orgId];
        if (!org.active) revert OrgNotActive(orgId);
        if (msg.sender == org.owner) {
            _;
            return;
        }
        // Check if caller has ADMIN or the specific permission
        uint256 roleId = _memberRoles[orgId][msg.sender];
        if (roleId == 0) revert InsufficientPermission(msg.sender, perm);
        RoleData storage role = _roles[orgId][roleId];
        if ((role.permissions & PERM_ADMIN) == 0 && (role.permissions & perm) == 0) {
            revert InsufficientPermission(msg.sender, perm);
        }
        _;
    }

    // ── Organization Management ──────────────────────────────

    function createOrganization(bytes32 orgId, address orgDID) external override {
        if (_organizations[orgId].orgDID != address(0)) revert OrgAlreadyExists(orgId);
        if (!didRegistry.isActive(orgDID)) revert DIDNotActive(orgDID);

        // Caller must be controller or delegate of the orgDID
        IDIDRegistryLocal.DIDDocument memory doc = didRegistry.resolveDID(orgDID);
        bool authorized = (doc.controller == msg.sender) || didRegistry.isDelegate(orgDID, msg.sender);
        if (!authorized) revert NotControllerOrDelegate(msg.sender, orgDID);

        _organizations[orgId] = OrganizationData({
            orgDID: orgDID,
            owner: msg.sender,
            memberCount: 0,
            active: true
        });

        emit OrganizationCreated(orgId, orgDID, msg.sender);
    }

    function deactivateOrganization(bytes32 orgId) external override {
        OrganizationData storage org = _organizations[orgId];
        if (org.orgDID == address(0)) revert OrgNotFound(orgId);
        if (msg.sender != org.owner) revert NotOrgOwner(msg.sender);
        org.active = false;
        emit OrganizationDeactivated(orgId);
    }

    function getOrganization(bytes32 orgId) external view override returns (
        address orgDID, address owner, uint256 memberCount, bool active
    ) {
        OrganizationData storage org = _organizations[orgId];
        return (org.orgDID, org.owner, org.memberCount, org.active);
    }

    // ── Role Management ──────────────────────────────────────

    function createRole(
        bytes32 orgId,
        bytes32 name,
        uint256 permissions
    ) external override onlyOrgOwnerOrPermission(orgId, PERM_MANAGE_ROLES) returns (uint256 roleId) {
        if (permissions == 0) revert InvalidPermissions();
        _roleCounter[orgId]++;
        roleId = _roleCounter[orgId];

        _roles[orgId][roleId] = RoleData({
            name: name,
            permissions: permissions,
            admin: msg.sender
        });

        emit RoleCreated(orgId, roleId, name, permissions);
    }

    function getRole(bytes32 orgId, uint256 roleId) external view override returns (
        bytes32 name, uint256 permissions, address admin
    ) {
        RoleData storage role = _roles[orgId][roleId];
        return (role.name, role.permissions, role.admin);
    }

    // ── Member Management ────────────────────────────────────

    function assignRole(
        bytes32 orgId,
        address member,
        uint256 roleId
    ) external override onlyOrgOwnerOrPermission(orgId, PERM_MANAGE_MEMBERS) {
        if (_roles[orgId][roleId].name == bytes32(0)) revert RoleNotFound(orgId, roleId);
        if (_memberRoles[orgId][member] != 0) revert MemberAlreadyAssigned(orgId, member);

        _memberRoles[orgId][member] = roleId;
        _organizations[orgId].memberCount++;

        emit RoleAssigned(orgId, member, roleId);
    }

    function revokeRole(
        bytes32 orgId,
        address member
    ) external override onlyOrgOwnerOrPermission(orgId, PERM_MANAGE_MEMBERS) {
        if (_memberRoles[orgId][member] == 0) revert MemberNotAssigned(orgId, member);

        delete _memberRoles[orgId][member];
        _organizations[orgId].memberCount--;

        emit RoleRevoked(orgId, member);
    }

    function getMemberRole(bytes32 orgId, address member) external view override returns (uint256) {
        return _memberRoles[orgId][member];
    }

    function hasPermission(bytes32 orgId, address member, uint256 permission) external view override returns (bool) {
        // Owner has all permissions
        if (_organizations[orgId].owner == member) return true;

        uint256 roleId = _memberRoles[orgId][member];
        if (roleId == 0) return false;

        RoleData storage role = _roles[orgId][roleId];
        // ADMIN has all permissions
        if ((role.permissions & PERM_ADMIN) != 0) return true;
        return (role.permissions & permission) != 0;
    }
}

Step 3: Verify compilation

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge build Expected: Compiles clean

Step 4: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add contracts/src/did/IEnterpriseIAMLocal.sol contracts/src/did/EnterpriseIAMLocal.sol
git commit -m "feat(iam): create IEnterpriseIAMLocal + EnterpriseIAMLocal contract"

---

Task 5: Enterprise IAM Tests

Files:

• Create: TEST/EnterpriseIAM.t.sol

Step 1: Write the test file

Create contracts/test/EnterpriseIAM.t.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

import "forge-std/Test.sol";
import "../src/did/DIDRegistryLocal.sol";
import "../src/did/EnterpriseIAMLocal.sol";

contract EnterpriseIAMTest is Test {
    DIDRegistryLocal public didRegistry;
    EnterpriseIAMLocal public iam;

    address orgOwner = makeAddr("orgOwner");
    address employee1 = makeAddr("employee1");
    address employee2 = makeAddr("employee2");
    address outsider = makeAddr("outsider");

    bytes32 orgId = keccak256("acme_corp");
    bytes32 serviceHash = keccak256("service");

    function setUp() public {
        didRegistry = new DIDRegistryLocal();
        iam = new EnterpriseIAMLocal(address(didRegistry));
        _createDID(orgOwner);
    }

    function _createDID(address user) internal {
        bytes32[] memory methods = new bytes32[](1);
        methods[0] = keccak256(abi.encodePacked("pubkey_", user));
        vm.prank(user);
        didRegistry.createDID(methods, serviceHash);
    }

    function _createOrg() internal {
        vm.prank(orgOwner);
        iam.createOrganization(orgId, orgOwner);
    }

    // ── createOrganization ───────────────────────────────────

    function test_createOrg_success() public {
        _createOrg();
        (address did, address owner, uint256 count, bool active) = iam.getOrganization(orgId);
        assertEq(did, orgOwner);
        assertEq(owner, orgOwner);
        assertEq(count, 0);
        assertTrue(active);
    }

    function test_createOrg_emitsEvent() public {
        vm.expectEmit(true, true, true, true);
        emit IEnterpriseIAMLocal.OrganizationCreated(orgId, orgOwner, orgOwner);
        vm.prank(orgOwner);
        iam.createOrganization(orgId, orgOwner);
    }

    function test_createOrg_revert_duplicateId() public {
        _createOrg();
        vm.prank(orgOwner);
        vm.expectRevert();
        iam.createOrganization(orgId, orgOwner);
    }

    function test_createOrg_revert_inactiveDID() public {
        vm.prank(outsider);
        vm.expectRevert();
        iam.createOrganization(keccak256("bad"), outsider);
    }

    function test_createOrg_revert_notControllerOrDelegate() public {
        vm.prank(outsider);
        _createDID(outsider);
        vm.prank(outsider);
        vm.expectRevert();
        iam.createOrganization(keccak256("bad2"), orgOwner);
    }

    function test_createOrg_byDelegate() public {
        _createDID(employee1);
        vm.prank(orgOwner);
        didRegistry.addDelegate(employee1, 365 days);
        vm.prank(employee1);
        iam.createOrganization(keccak256("delegateOrg"), orgOwner);
        (,address owner,,) = iam.getOrganization(keccak256("delegateOrg"));
        assertEq(owner, employee1);
    }

    // ── deactivateOrganization ───────────────────────────────

    function test_deactivateOrg_success() public {
        _createOrg();
        vm.prank(orgOwner);
        iam.deactivateOrganization(orgId);
        (,,, bool active) = iam.getOrganization(orgId);
        assertFalse(active);
    }

    function test_deactivateOrg_revert_notOwner() public {
        _createOrg();
        vm.prank(outsider);
        vm.expectRevert();
        iam.deactivateOrganization(orgId);
    }

    // ── createRole ───────────────────────────────────────────

    function test_createRole_success() public {
        _createOrg();
        uint256 perms = iam.PERM_ISSUE_CREDENTIAL() | iam.PERM_REVOKE_CREDENTIAL();
        vm.prank(orgOwner);
        uint256 roleId = iam.createRole(orgId, keccak256("issuer"), perms);
        assertEq(roleId, 1);

        (bytes32 name, uint256 p, address admin) = iam.getRole(orgId, roleId);
        assertEq(name, keccak256("issuer"));
        assertEq(p, perms);
        assertEq(admin, orgOwner);
    }

    function test_createRole_emitsEvent() public {
        _createOrg();
        uint256 perms = iam.PERM_ISSUE_CREDENTIAL();
        vm.expectEmit(true, true, false, true);
        emit IEnterpriseIAMLocal.RoleCreated(orgId, 1, keccak256("issuer"), perms);
        vm.prank(orgOwner);
        iam.createRole(orgId, keccak256("issuer"), perms);
    }

    function test_createRole_revert_zeroPermissions() public {
        _createOrg();
        vm.prank(orgOwner);
        vm.expectRevert();
        iam.createRole(orgId, keccak256("empty"), 0);
    }

    function test_createRole_revert_notOwnerOrPermitted() public {
        _createOrg();
        vm.prank(outsider);
        vm.expectRevert();
        iam.createRole(orgId, keccak256("bad"), 1);
    }

    // ── assignRole + revokeRole ──────────────────────────────

    function test_assignRole_success() public {
        _createOrg();
        vm.prank(orgOwner);
        uint256 roleId = iam.createRole(orgId, keccak256("viewer"), iam.PERM_VIEW_REPORTS());
        vm.prank(orgOwner);
        iam.assignRole(orgId, employee1, roleId);

        assertEq(iam.getMemberRole(orgId, employee1), roleId);
        (,, uint256 count,) = iam.getOrganization(orgId);
        assertEq(count, 1);
    }

    function test_assignRole_emitsEvent() public {
        _createOrg();
        vm.prank(orgOwner);
        uint256 roleId = iam.createRole(orgId, keccak256("viewer"), iam.PERM_VIEW_REPORTS());
        vm.expectEmit(true, true, true, true);
        emit IEnterpriseIAMLocal.RoleAssigned(orgId, employee1, roleId);
        vm.prank(orgOwner);
        iam.assignRole(orgId, employee1, roleId);
    }

    function test_assignRole_revert_nonexistentRole() public {
        _createOrg();
        vm.prank(orgOwner);
        vm.expectRevert();
        iam.assignRole(orgId, employee1, 999);
    }

    function test_assignRole_revert_alreadyAssigned() public {
        _createOrg();
        vm.prank(orgOwner);
        uint256 roleId = iam.createRole(orgId, keccak256("viewer"), iam.PERM_VIEW_REPORTS());
        vm.prank(orgOwner);
        iam.assignRole(orgId, employee1, roleId);
        vm.prank(orgOwner);
        vm.expectRevert();
        iam.assignRole(orgId, employee1, roleId);
    }

    function test_revokeRole_success() public {
        _createOrg();
        vm.prank(orgOwner);
        uint256 roleId = iam.createRole(orgId, keccak256("viewer"), iam.PERM_VIEW_REPORTS());
        vm.prank(orgOwner);
        iam.assignRole(orgId, employee1, roleId);
        vm.prank(orgOwner);
        iam.revokeRole(orgId, employee1);

        assertEq(iam.getMemberRole(orgId, employee1), 0);
        (,, uint256 count,) = iam.getOrganization(orgId);
        assertEq(count, 0);
    }

    function test_revokeRole_emitsEvent() public {
        _createOrg();
        vm.prank(orgOwner);
        uint256 roleId = iam.createRole(orgId, keccak256("viewer"), iam.PERM_VIEW_REPORTS());
        vm.prank(orgOwner);
        iam.assignRole(orgId, employee1, roleId);
        vm.expectEmit(true, true, false, true);
        emit IEnterpriseIAMLocal.RoleRevoked(orgId, employee1);
        vm.prank(orgOwner);
        iam.revokeRole(orgId, employee1);
    }

    function test_revokeRole_revert_notAssigned() public {
        _createOrg();
        vm.prank(orgOwner);
        vm.expectRevert();
        iam.revokeRole(orgId, employee1);
    }

    // ── hasPermission ────────────────────────────────────────

    function test_hasPermission_ownerHasAll() public {
        _createOrg();
        assertTrue(iam.hasPermission(orgId, orgOwner, iam.PERM_ADMIN()));
        assertTrue(iam.hasPermission(orgId, orgOwner, iam.PERM_ISSUE_CREDENTIAL()));
    }

    function test_hasPermission_memberWithPermission() public {
        _createOrg();
        uint256 perms = iam.PERM_ISSUE_CREDENTIAL() | iam.PERM_VIEW_REPORTS();
        vm.prank(orgOwner);
        uint256 roleId = iam.createRole(orgId, keccak256("issuer"), perms);
        vm.prank(orgOwner);
        iam.assignRole(orgId, employee1, roleId);

        assertTrue(iam.hasPermission(orgId, employee1, iam.PERM_ISSUE_CREDENTIAL()));
        assertTrue(iam.hasPermission(orgId, employee1, iam.PERM_VIEW_REPORTS()));
        assertFalse(iam.hasPermission(orgId, employee1, iam.PERM_MANAGE_MEMBERS()));
    }

    function test_hasPermission_adminHasAll() public {
        _createOrg();
        vm.prank(orgOwner);
        uint256 roleId = iam.createRole(orgId, keccak256("admin"), iam.PERM_ADMIN());
        vm.prank(orgOwner);
        iam.assignRole(orgId, employee1, roleId);

        assertTrue(iam.hasPermission(orgId, employee1, iam.PERM_ISSUE_CREDENTIAL()));
        assertTrue(iam.hasPermission(orgId, employee1, iam.PERM_MANAGE_MEMBERS()));
    }

    function test_hasPermission_outsiderHasNone() public {
        _createOrg();
        assertFalse(iam.hasPermission(orgId, outsider, iam.PERM_VIEW_REPORTS()));
    }

    // ── Delegated Role Management ────────────────────────────

    function test_memberWithManageRoles_canCreateRole() public {
        _createOrg();
        vm.prank(orgOwner);
        uint256 managerRoleId = iam.createRole(orgId, keccak256("manager"), iam.PERM_MANAGE_ROLES() | iam.PERM_MANAGE_MEMBERS());
        vm.prank(orgOwner);
        iam.assignRole(orgId, employee1, managerRoleId);

        // employee1 can now create roles
        vm.prank(employee1);
        uint256 newRoleId = iam.createRole(orgId, keccak256("viewer"), iam.PERM_VIEW_REPORTS());
        assertEq(newRoleId, 2);

        // employee1 can also assign roles
        vm.prank(employee1);
        iam.assignRole(orgId, employee2, newRoleId);
        assertTrue(iam.hasPermission(orgId, employee2, iam.PERM_VIEW_REPORTS()));
    }
}

Step 2: Run tests

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test --match-contract EnterpriseIAMTest -v Expected: All tests pass (~22 tests)

Step 3: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add contracts/test/EnterpriseIAM.t.sol
git commit -m "test(iam): add 22 enterprise IAM tests"

---

Task 6: IdentityVerifierLocal — Add Selective Disclosure

Files:

• Modify: DID_SRC/IdentityVerifierLocal.sol:1-217

Step 1: Add disclosure storage after _usedProofs (line 27)

After mapping(bytes32 => bool) private _usedProofs; (line 27), add:

    // ── Selective Disclosure Storage ──────────────────────────
    struct DisclosurePolicy {
        bytes32 credentialType;
        bytes32[] requiredAttributes;
        uint8 circuitType;
        bool active;
    }

    mapping(bytes32 => DisclosurePolicy) private _disclosurePolicies;
    mapping(address => mapping(bytes32 => bool)) private _disclosureResults;

    event DisclosurePolicyRegistered(bytes32 indexed policyId, bytes32 credentialType, uint8 circuitType);
    event SelectiveDisclosureVerified(address indexed identity, bytes32 indexed policyId);

Step 2: Add new errors after existing errors (after line 36 InvalidProof)

    error PolicyAlreadyExists(bytes32 policyId);
    error PolicyNotFound(bytes32 policyId);
    error PolicyNotActive(bytes32 policyId);

Step 3: Add disclosure functions before setOracleHub (before line 162)

Insert before the setOracleHub function:

    // ── Selective Disclosure ──────────────────────────────────

    function registerDisclosurePolicy(
        bytes32 policyId,
        bytes32 credentialType,
        bytes32[] calldata requiredAttributes,
        uint8 circuitType
    ) external onlyAdmin {
        if (_disclosurePolicies[policyId].active) revert PolicyAlreadyExists(policyId);
        if (_circuitVerifiers[circuitType] == address(0)) revert CircuitNotRegistered(circuitType);

        DisclosurePolicy storage policy = _disclosurePolicies[policyId];
        policy.credentialType = credentialType;
        policy.circuitType = circuitType;
        policy.active = true;
        for (uint256 i = 0; i < requiredAttributes.length; i++) {
            policy.requiredAttributes.push(requiredAttributes[i]);
        }

        emit DisclosurePolicyRegistered(policyId, credentialType, circuitType);
    }

    function verifySelectiveDisclosure(
        address identity,
        bytes32 policyId,
        uint256[2] calldata _pA,
        uint256[2][2] calldata _pB,
        uint256[2] calldata _pC,
        uint256[] calldata publicInputs
    ) external returns (bool) {
        if (!didRegistry.isActive(identity)) revert IdentityNotActive(identity);

        DisclosurePolicy storage policy = _disclosurePolicies[policyId];
        if (!policy.active) revert PolicyNotActive(policyId);

        address verifierAddr = _circuitVerifiers[policy.circuitType];
        if (verifierAddr == address(0)) revert CircuitNotRegistered(policy.circuitType);

        // Replay protection
        bytes32 proofHash = keccak256(abi.encode(identity, policyId, _pA, _pB, _pC, publicInputs));
        if (_usedProofs[proofHash]) revert ProofAlreadyUsed(proofHash);

        // Verify proof
        bool valid = IGroth16Verifier(verifierAddr).verifyProof(_pA, _pB, _pC, publicInputs);
        if (!valid) revert InvalidProof();

        _usedProofs[proofHash] = true;
        _disclosureResults[identity][policyId] = true;

        // Set compliance key for cross-contract queries
        bytes32 complianceKey = keccak256(abi.encodePacked("SD_", policyId));
        _compliance[identity][complianceKey] = true;
        emit ComplianceUpdated(identity, complianceKey, true);
        emit SelectiveDisclosureVerified(identity, policyId);

        return true;
    }

    function hasValidDisclosure(address identity, bytes32 policyId) external view returns (bool) {
        return _disclosureResults[identity][policyId];
    }

    function getDisclosurePolicy(bytes32 policyId) external view returns (
        bytes32 credentialType, bytes32[] memory requiredAttributes, uint8 circuitType, bool active
    ) {
        DisclosurePolicy storage policy = _disclosurePolicies[policyId];
        return (policy.credentialType, policy.requiredAttributes, policy.circuitType, policy.active);
    }

Step 4: Verify compilation

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge build Expected: Compiles clean

Step 5: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add contracts/src/did/IdentityVerifierLocal.sol
git commit -m "feat(verifier): add selective disclosure to IdentityVerifierLocal"

---

Task 7: Selective Disclosure Tests

Files:

• Create: TEST/IdentityVerifierDisclosure.t.sol

Step 1: Write the test file

Create contracts/test/IdentityVerifierDisclosure.t.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

import "forge-std/Test.sol";
import "../src/did/DIDRegistryLocal.sol";
import "../src/did/CredentialRegistryLocal.sol";
import "../src/did/IdentityVerifierLocal.sol";
import "../src/did/MockGroth16Verifier.sol";

contract IdentityVerifierDisclosureTest is Test {
    DIDRegistryLocal public didRegistry;
    CredentialRegistryLocal public credRegistry;
    IdentityVerifierLocal public verifier;
    MockGroth16Verifier public ageVerifier;
    MockGroth16Verifier public incomeVerifier;
    MockGroth16Verifier public failVerifier;

    address admin = makeAddr("admin");
    address subject = makeAddr("subject");
    address outsider = makeAddr("outsider");

    bytes32 serviceHash = keccak256("service");
    bytes32 AGE_POLICY = keccak256("AGE_18_PLUS");
    bytes32 INCOME_POLICY = keccak256("INCOME_RANGE");
    uint8 AGE_CIRCUIT = 3;
    uint8 INCOME_CIRCUIT = 4;

    // Dummy proof data
    uint256[2] pA = [uint256(1), uint256(2)];
    uint256[2][2] pB = [[uint256(3), uint256(4)], [uint256(5), uint256(6)]];
    uint256[2] pC = [uint256(7), uint256(8)];

    function setUp() public {
        didRegistry = new DIDRegistryLocal();
        credRegistry = new CredentialRegistryLocal(address(didRegistry));
        verifier = new IdentityVerifierLocal(address(didRegistry), address(credRegistry), admin);

        // Deploy mock verifiers
        ageVerifier = new MockGroth16Verifier(true);
        incomeVerifier = new MockGroth16Verifier(true);
        failVerifier = new MockGroth16Verifier(false);

        // Register circuit verifiers
        vm.startPrank(admin);
        verifier.setCircuitVerifier(AGE_CIRCUIT, address(ageVerifier));
        verifier.setCircuitVerifier(INCOME_CIRCUIT, address(incomeVerifier));
        vm.stopPrank();

        // Create subject DID
        _createDID(subject);
    }

    function _createDID(address user) internal {
        bytes32[] memory methods = new bytes32[](1);
        methods[0] = keccak256(abi.encodePacked("pubkey_", user));
        vm.prank(user);
        didRegistry.createDID(methods, serviceHash);
    }

    function _publicInputs() internal pure returns (uint256[] memory) {
        uint256[] memory inputs = new uint256[](1);
        inputs[0] = 42;
        return inputs;
    }

    // ── registerDisclosurePolicy ─────────────────────────────

    function test_registerPolicy_success() public {
        bytes32[] memory attrs = new bytes32[](2);
        attrs[0] = keccak256("age");
        attrs[1] = keccak256("birthYear");

        vm.prank(admin);
        verifier.registerDisclosurePolicy(AGE_POLICY, keccak256("KYC"), attrs, AGE_CIRCUIT);

        (bytes32 credType, bytes32[] memory reqAttrs, uint8 circuit, bool active) = verifier.getDisclosurePolicy(AGE_POLICY);
        assertEq(credType, keccak256("KYC"));
        assertEq(reqAttrs.length, 2);
        assertEq(circuit, AGE_CIRCUIT);
        assertTrue(active);
    }

    function test_registerPolicy_revert_notAdmin() public {
        bytes32[] memory attrs = new bytes32[](1);
        attrs[0] = keccak256("age");
        vm.prank(outsider);
        vm.expectRevert();
        verifier.registerDisclosurePolicy(AGE_POLICY, keccak256("KYC"), attrs, AGE_CIRCUIT);
    }

    function test_registerPolicy_revert_duplicate() public {
        bytes32[] memory attrs = new bytes32[](1);
        attrs[0] = keccak256("age");
        vm.prank(admin);
        verifier.registerDisclosurePolicy(AGE_POLICY, keccak256("KYC"), attrs, AGE_CIRCUIT);
        vm.prank(admin);
        vm.expectRevert();
        verifier.registerDisclosurePolicy(AGE_POLICY, keccak256("KYC"), attrs, AGE_CIRCUIT);
    }

    function test_registerPolicy_revert_unregisteredCircuit() public {
        bytes32[] memory attrs = new bytes32[](1);
        attrs[0] = keccak256("region");
        vm.prank(admin);
        vm.expectRevert();
        verifier.registerDisclosurePolicy(keccak256("REGION"), keccak256("KYC"), attrs, 99);
    }

    // ── verifySelectiveDisclosure ────────────────────────────

    function test_verifyDisclosure_success() public {
        bytes32[] memory attrs = new bytes32[](1);
        attrs[0] = keccak256("age");
        vm.prank(admin);
        verifier.registerDisclosurePolicy(AGE_POLICY, keccak256("KYC"), attrs, AGE_CIRCUIT);

        bool result = verifier.verifySelectiveDisclosure(subject, AGE_POLICY, pA, pB, pC, _publicInputs());
        assertTrue(result);
        assertTrue(verifier.hasValidDisclosure(subject, AGE_POLICY));
    }

    function test_verifyDisclosure_setsCompliance() public {
        bytes32[] memory attrs = new bytes32[](1);
        attrs[0] = keccak256("age");
        vm.prank(admin);
        verifier.registerDisclosurePolicy(AGE_POLICY, keccak256("KYC"), attrs, AGE_CIRCUIT);

        verifier.verifySelectiveDisclosure(subject, AGE_POLICY, pA, pB, pC, _publicInputs());

        bytes32 complianceKey = keccak256(abi.encodePacked("SD_", AGE_POLICY));
        assertTrue(verifier.checkCompliance(subject, complianceKey));
    }

    function test_verifyDisclosure_revert_inactiveDID() public {
        bytes32[] memory attrs = new bytes32[](1);
        attrs[0] = keccak256("age");
        vm.prank(admin);
        verifier.registerDisclosurePolicy(AGE_POLICY, keccak256("KYC"), attrs, AGE_CIRCUIT);

        vm.prank(subject);
        didRegistry.deactivateDID();

        vm.expectRevert();
        verifier.verifySelectiveDisclosure(subject, AGE_POLICY, pA, pB, pC, _publicInputs());
    }

    function test_verifyDisclosure_revert_inactivePolicy() public {
        vm.expectRevert();
        verifier.verifySelectiveDisclosure(subject, AGE_POLICY, pA, pB, pC, _publicInputs());
    }

    function test_verifyDisclosure_revert_invalidProof() public {
        // Register policy with failing verifier
        vm.startPrank(admin);
        verifier.setCircuitVerifier(5, address(failVerifier));
        bytes32[] memory attrs = new bytes32[](1);
        attrs[0] = keccak256("region");
        verifier.registerDisclosurePolicy(keccak256("REGION"), keccak256("KYC"), attrs, 5);
        vm.stopPrank();

        vm.expectRevert();
        verifier.verifySelectiveDisclosure(subject, keccak256("REGION"), pA, pB, pC, _publicInputs());
    }

    function test_verifyDisclosure_revert_replayProof() public {
        bytes32[] memory attrs = new bytes32[](1);
        attrs[0] = keccak256("age");
        vm.prank(admin);
        verifier.registerDisclosurePolicy(AGE_POLICY, keccak256("KYC"), attrs, AGE_CIRCUIT);

        verifier.verifySelectiveDisclosure(subject, AGE_POLICY, pA, pB, pC, _publicInputs());

        // Same proof again
        vm.expectRevert();
        verifier.verifySelectiveDisclosure(subject, AGE_POLICY, pA, pB, pC, _publicInputs());
    }

    function test_hasValidDisclosure_returnsFalseBeforeVerification() public {
        assertFalse(verifier.hasValidDisclosure(subject, AGE_POLICY));
    }

    // ── Multiple Policies ────────────────────────────────────

    function test_multipleDisclosures() public {
        bytes32[] memory ageAttrs = new bytes32[](1);
        ageAttrs[0] = keccak256("age");
        bytes32[] memory incomeAttrs = new bytes32[](1);
        incomeAttrs[0] = keccak256("income");

        vm.startPrank(admin);
        verifier.registerDisclosurePolicy(AGE_POLICY, keccak256("KYC"), ageAttrs, AGE_CIRCUIT);
        verifier.registerDisclosurePolicy(INCOME_POLICY, keccak256("CREDIT"), incomeAttrs, INCOME_CIRCUIT);
        vm.stopPrank();

        // Different public inputs to avoid replay
        uint256[] memory inputs1 = new uint256[](1);
        inputs1[0] = 1;
        uint256[] memory inputs2 = new uint256[](1);
        inputs2[0] = 2;

        verifier.verifySelectiveDisclosure(subject, AGE_POLICY, pA, pB, pC, inputs1);
        verifier.verifySelectiveDisclosure(subject, INCOME_POLICY, pA, pB, pC, inputs2);

        assertTrue(verifier.hasValidDisclosure(subject, AGE_POLICY));
        assertTrue(verifier.hasValidDisclosure(subject, INCOME_POLICY));
    }
}

Step 2: Run tests

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test --match-contract IdentityVerifierDisclosureTest -v Expected: All tests pass (~13 tests)

Step 3: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add contracts/test/IdentityVerifierDisclosure.t.sol
git commit -m "test(verifier): add 13 selective disclosure tests"

---

Task 8: System Contracts — Update IDIDRegistry Interface

Files:

• Modify: SYS/interfaces/IDIDRegistry.sol:1-36

Step 1: Add recovery events and functions to the system contract interface

After line 20 (DelegateRevoked event), add:

    // ── Social Recovery Events ────────────────────────────────
    event RecoveryConfigured(address indexed identity, uint8 threshold, uint8 guardianCount);
    event RecoveryInitiated(address indexed identity, address indexed newController, address indexed initiator);
    event RecoveryApproved(address indexed identity, address indexed guardian, uint8 approvalCount);
    event RecoveryExecuted(address indexed identity, address indexed oldController, address indexed newController);
    event RecoveryCancelled(address indexed identity);

After line 35 (getNonce function), before the closing }, add:

    // ── Social Recovery ──────────────────────────────────────
    function setRecovery(address[] calldata guardians, uint8 threshold, uint64 timelockDuration) external;
    function initiateRecovery(address identity, address newController) external;
    function approveRecovery(address identity) external;
    function executeRecovery(address identity) external;
    function cancelRecovery() external;
    function getRecoveryConfig(address identity) external view returns (address[] memory guardians, uint8 threshold, uint64 timelockDuration);
    function getRecoveryRequest(address identity) external view returns (address newController, uint64 initiatedAt, uint8 approvalCount, bool executable);

Step 2: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add era-contracts-l1/system-contracts/contracts/interfaces/IDIDRegistry.sol
git commit -m "feat(sys): add social recovery interface to IDIDRegistry"

---

Task 9: System Contracts — DIDRegistry Social Recovery Implementation

Files:

• Modify: SYS/DIDRegistry.sol:1-180

Step 1: Add recovery errors after existing errors (after line 28 EmptyVerificationMethods)

    error RecoveryNotConfigured(address identity);
    error RecoveryAlreadyPending(address identity);
    error RecoveryNotPending(address identity);
    error NotGuardian(address caller);
    error AlreadyApproved(address guardian);
    error RecoveryNotExecutable();
    error InvalidRecoveryConfig();
    error GuardianIsSelf(address identity);
    error DuplicateGuardian(address guardian);
    error TimelockTooShort();

Step 2: Add recovery storage after _nonces (after line 18)

    // ── Recovery Storage ─────────────────────────────────────
    struct RecoveryConfig {
        address[] guardians;
        uint8 threshold;
        uint64 timelockDuration;
    }

    struct RecoveryRequestData {
        address newController;
        uint64 initiatedAt;
        uint8 approvalCount;
    }

    mapping(address => RecoveryConfig) private _recoveryConfigs;
    mapping(address => RecoveryRequestData) private _recoveryRequests;
    mapping(address => mapping(address => bool)) private _recoveryApprovals;

Step 3: Add recovery functions at the end of the contract (before closing })

Same logic as DIDRegistryLocal (Task 2), but with L1Messenger sync for initiateRecovery and executeRecovery:

    // ── Social Recovery ──────────────────────────────────────

    function setRecovery(
        address[] calldata guardians,
        uint8 threshold,
        uint64 timelockDuration
    ) external override onlyController(msg.sender) {
        if (!_documents[msg.sender].active) revert DIDNotActive(msg.sender);
        if (threshold == 0 || threshold > guardians.length || guardians.length > 7) revert InvalidRecoveryConfig();
        if (timelockDuration < 1 hours) revert TimelockTooShort();

        for (uint256 i = 0; i < guardians.length; i++) {
            if (guardians[i] == msg.sender) revert GuardianIsSelf(msg.sender);
            for (uint256 j = i + 1; j < guardians.length; j++) {
                if (guardians[i] == guardians[j]) revert DuplicateGuardian(guardians[i]);
            }
        }

        _recoveryConfigs[msg.sender] = RecoveryConfig({
            guardians: guardians,
            threshold: threshold,
            timelockDuration: timelockDuration
        });

        _clearRecoveryRequest(msg.sender);
        emit RecoveryConfigured(msg.sender, threshold, uint8(guardians.length));
    }

    function initiateRecovery(
        address identity,
        address newController
    ) external override {
        RecoveryConfig storage config = _recoveryConfigs[identity];
        if (config.guardians.length == 0) revert RecoveryNotConfigured(identity);
        if (_recoveryRequests[identity].initiatedAt != 0) revert RecoveryAlreadyPending(identity);
        if (!_isGuardian(identity, msg.sender)) revert NotGuardian(msg.sender);
        if (newController == address(0)) revert InvalidRecoveryConfig();

        _recoveryRequests[identity] = RecoveryRequestData({
            newController: newController,
            initiatedAt: uint64(block.timestamp),
            approvalCount: 1
        });
        _recoveryApprovals[identity][msg.sender] = true;

        emit RecoveryInitiated(identity, newController, msg.sender);

        // L1 sync — Type 8
        L1_MESSENGER_CONTRACT.sendToL1(
            abi.encode(uint8(8), identity, newController, block.timestamp)
        );
    }

    function approveRecovery(address identity) external override {
        if (_recoveryRequests[identity].initiatedAt == 0) revert RecoveryNotPending(identity);
        if (!_isGuardian(identity, msg.sender)) revert NotGuardian(msg.sender);
        if (_recoveryApprovals[identity][msg.sender]) revert AlreadyApproved(msg.sender);

        _recoveryApprovals[identity][msg.sender] = true;
        _recoveryRequests[identity].approvalCount++;

        emit RecoveryApproved(identity, msg.sender, _recoveryRequests[identity].approvalCount);
    }

    function executeRecovery(address identity) external override {
        RecoveryRequestData storage req = _recoveryRequests[identity];
        RecoveryConfig storage config = _recoveryConfigs[identity];
        if (req.initiatedAt == 0) revert RecoveryNotPending(identity);
        if (req.approvalCount < config.threshold) revert RecoveryNotExecutable();
        if (block.timestamp < req.initiatedAt + config.timelockDuration) revert RecoveryNotExecutable();

        address oldController = _documents[identity].controller;
        address newController = req.newController;

        _documents[identity].controller = newController;
        _documents[identity].updated = uint64(block.timestamp);
        _nonces[identity]++;

        _clearRecoveryRequest(identity);

        emit RecoveryExecuted(identity, oldController, newController);

        // L1 sync — Type 9
        L1_MESSENGER_CONTRACT.sendToL1(
            abi.encode(uint8(9), identity, oldController, newController, _nonces[identity])
        );
    }

    function cancelRecovery() external override onlyController(msg.sender) {
        if (_recoveryRequests[msg.sender].initiatedAt == 0) revert RecoveryNotPending(msg.sender);
        _clearRecoveryRequest(msg.sender);
        emit RecoveryCancelled(msg.sender);
    }

    function getRecoveryConfig(address identity) external view override returns (
        address[] memory guardians, uint8 threshold, uint64 timelockDuration
    ) {
        RecoveryConfig storage config = _recoveryConfigs[identity];
        return (config.guardians, config.threshold, config.timelockDuration);
    }

    function getRecoveryRequest(address identity) external view override returns (
        address newController, uint64 initiatedAt, uint8 approvalCount, bool executable
    ) {
        RecoveryRequestData storage req = _recoveryRequests[identity];
        RecoveryConfig storage config = _recoveryConfigs[identity];
        bool exec = req.initiatedAt != 0
            && req.approvalCount >= config.threshold
            && block.timestamp >= req.initiatedAt + config.timelockDuration;
        return (req.newController, req.initiatedAt, req.approvalCount, exec);
    }

    function _isGuardian(address identity, address account) internal view returns (bool) {
        RecoveryConfig storage config = _recoveryConfigs[identity];
        for (uint256 i = 0; i < config.guardians.length; i++) {
            if (config.guardians[i] == account) return true;
        }
        return false;
    }

    function _clearRecoveryRequest(address identity) internal {
        RecoveryConfig storage config = _recoveryConfigs[identity];
        for (uint256 i = 0; i < config.guardians.length; i++) {
            _recoveryApprovals[identity][config.guardians[i]] = false;
        }
        delete _recoveryRequests[identity];
    }

Step 4: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add era-contracts-l1/system-contracts/contracts/DIDRegistry.sol
git commit -m "feat(sys): implement social recovery in DIDRegistry system contract"

---

Task 10: System Contracts — IEnterpriseIAM + EnterpriseIAM + Constants Registration

Files:

• Create: SYS/interfaces/IEnterpriseIAM.sol

• Create: SYS/EnterpriseIAM.sol

• Modify: SYS/Constants.sol:121

Step 1: Add constant to Constants.sol after line 121 (after IDENTITY_VERIFIER)

After line 121 (address constant IDENTITY_VERIFIER_SYSTEM_CONTRACT = ...;), add:

/// @dev The address of the EnterpriseIAM system contract.
address constant ENTERPRISE_IAM_SYSTEM_CONTRACT = address(SYSTEM_CONTRACTS_OFFSET + 0x1a);

Step 2: Create the IEnterpriseIAM interface

Create SYS/interfaces/IEnterpriseIAM.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

interface IEnterpriseIAM {
    // ── Events ───────────────────────────────────────────────
    event OrganizationCreated(bytes32 indexed orgId, address indexed orgDID, address indexed owner);
    event OrganizationDeactivated(bytes32 indexed orgId);
    event RoleCreated(bytes32 indexed orgId, uint256 indexed roleId, bytes32 name, uint256 permissions);
    event RoleAssigned(bytes32 indexed orgId, address indexed member, uint256 indexed roleId);
    event RoleRevoked(bytes32 indexed orgId, address indexed member);

    // ── Organization Management ──────────────────────────────
    function createOrganization(bytes32 orgId, address orgDID) external;
    function deactivateOrganization(bytes32 orgId) external;
    function getOrganization(bytes32 orgId) external view returns (address orgDID, address owner, uint256 memberCount, bool active);

    // ── Role Management ──────────────────────────────────────
    function createRole(bytes32 orgId, bytes32 name, uint256 permissions) external returns (uint256 roleId);
    function getRole(bytes32 orgId, uint256 roleId) external view returns (bytes32 name, uint256 permissions, address admin);

    // ── Member Management ────────────────────────────────────
    function assignRole(bytes32 orgId, address member, uint256 roleId) external;
    function revokeRole(bytes32 orgId, address member) external;
    function getMemberRole(bytes32 orgId, address member) external view returns (uint256);
    function hasPermission(bytes32 orgId, address member, uint256 permission) external view returns (bool);
}

Step 3: Create the EnterpriseIAM system contract

Create SYS/EnterpriseIAM.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import {IEnterpriseIAM} from "./interfaces/IEnterpriseIAM.sol";
import {SystemContractBase} from "./abstract/SystemContractBase.sol";
import {DID_REGISTRY_SYSTEM_CONTRACT, L1_MESSENGER_CONTRACT} from "./Constants.sol";
import {IDIDRegistry} from "./interfaces/IDIDRegistry.sol";
import {IL1Messenger} from "./interfaces/IL1Messenger.sol";

/// @title EnterpriseIAM — BabyDriver Enterprise Identity & Access Management
/// @notice System contract at 0x801A. Manages organizations, roles, and permissions.
contract EnterpriseIAM is IEnterpriseIAM, SystemContractBase {
    // ── Permission Constants ─────────────────────────────────
    uint256 public constant PERM_ISSUE_CREDENTIAL   = 1 << 0;
    uint256 public constant PERM_REVOKE_CREDENTIAL  = 1 << 1;
    uint256 public constant PERM_MANAGE_MEMBERS     = 1 << 2;
    uint256 public constant PERM_MANAGE_ROLES       = 1 << 3;
    uint256 public constant PERM_VIEW_REPORTS       = 1 << 4;
    uint256 public constant PERM_MANAGE_COMPLIANCE  = 1 << 5;
    uint256 public constant PERM_ADMIN              = 1 << 6;
    uint256 public constant PERM_SIGN_TRANSACTIONS  = 1 << 7;

    // ── Storage ──────────────────────────────────────────────
    struct OrganizationData {
        address orgDID;
        address owner;
        uint256 memberCount;
        bool active;
    }

    struct RoleData {
        bytes32 name;
        uint256 permissions;
        address admin;
    }

    mapping(bytes32 => OrganizationData) private _organizations;
    mapping(bytes32 => mapping(uint256 => RoleData)) private _roles;
    mapping(bytes32 => mapping(address => uint256)) private _memberRoles;
    mapping(bytes32 => uint256) private _roleCounter;

    // ── Errors ───────────────────────────────────────────────
    error OrgAlreadyExists(bytes32 orgId);
    error OrgNotFound(bytes32 orgId);
    error OrgNotActive(bytes32 orgId);
    error NotOrgOwner(address caller);
    error InsufficientPermission(address caller, uint256 required);
    error DIDNotActive(address orgDID);
    error NotControllerOrDelegate(address caller, address orgDID);
    error RoleNotFound(bytes32 orgId, uint256 roleId);
    error MemberAlreadyAssigned(bytes32 orgId, address member);
    error MemberNotAssigned(bytes32 orgId, address member);
    error InvalidPermissions();

    // ── Helpers ──────────────────────────────────────────────
    function _didRegistry() internal pure returns (IDIDRegistry) {
        return IDIDRegistry(DID_REGISTRY_SYSTEM_CONTRACT);
    }

    // ── Modifiers ────────────────────────────────────────────
    modifier onlyOrgOwnerOrPermission(bytes32 orgId, uint256 perm) {
        OrganizationData storage org = _organizations[orgId];
        if (!org.active) revert OrgNotActive(orgId);
        if (msg.sender == org.owner) {
            _;
            return;
        }
        uint256 roleId = _memberRoles[orgId][msg.sender];
        if (roleId == 0) revert InsufficientPermission(msg.sender, perm);
        RoleData storage role = _roles[orgId][roleId];
        if ((role.permissions & PERM_ADMIN) == 0 && (role.permissions & perm) == 0) {
            revert InsufficientPermission(msg.sender, perm);
        }
        _;
    }

    // ── Organization Management ──────────────────────────────

    function createOrganization(bytes32 orgId, address orgDID) external override onlySystemCall {
        if (_organizations[orgId].orgDID != address(0)) revert OrgAlreadyExists(orgId);
        if (!_didRegistry().isActive(orgDID)) revert DIDNotActive(orgDID);

        IDIDRegistry.DIDDocument memory doc = _didRegistry().resolveDID(orgDID);
        bool authorized = (doc.controller == msg.sender) || _didRegistry().isDelegate(orgDID, msg.sender);
        if (!authorized) revert NotControllerOrDelegate(msg.sender, orgDID);

        _organizations[orgId] = OrganizationData({
            orgDID: orgDID,
            owner: msg.sender,
            memberCount: 0,
            active: true
        });

        emit OrganizationCreated(orgId, orgDID, msg.sender);

        // L1 sync — Type 10
        L1_MESSENGER_CONTRACT.sendToL1(
            abi.encode(uint8(10), orgId, orgDID, msg.sender)
        );
    }

    function deactivateOrganization(bytes32 orgId) external override onlySystemCall {
        OrganizationData storage org = _organizations[orgId];
        if (org.orgDID == address(0)) revert OrgNotFound(orgId);
        if (msg.sender != org.owner) revert NotOrgOwner(msg.sender);
        org.active = false;
        emit OrganizationDeactivated(orgId);
    }

    function getOrganization(bytes32 orgId) external view override returns (
        address orgDID, address owner, uint256 memberCount, bool active
    ) {
        OrganizationData storage org = _organizations[orgId];
        return (org.orgDID, org.owner, org.memberCount, org.active);
    }

    // ── Role Management ──────────────────────────────────────

    function createRole(
        bytes32 orgId,
        bytes32 name,
        uint256 permissions
    ) external override onlyOrgOwnerOrPermission(orgId, PERM_MANAGE_ROLES) returns (uint256 roleId) {
        if (permissions == 0) revert InvalidPermissions();
        _roleCounter[orgId]++;
        roleId = _roleCounter[orgId];

        _roles[orgId][roleId] = RoleData({
            name: name,
            permissions: permissions,
            admin: msg.sender
        });

        emit RoleCreated(orgId, roleId, name, permissions);
    }

    function getRole(bytes32 orgId, uint256 roleId) external view override returns (
        bytes32 name, uint256 permissions, address admin
    ) {
        RoleData storage role = _roles[orgId][roleId];
        return (role.name, role.permissions, role.admin);
    }

    // ── Member Management ────────────────────────────────────

    function assignRole(
        bytes32 orgId,
        address member,
        uint256 roleId
    ) external override onlyOrgOwnerOrPermission(orgId, PERM_MANAGE_MEMBERS) {
        if (_roles[orgId][roleId].name == bytes32(0)) revert RoleNotFound(orgId, roleId);
        if (_memberRoles[orgId][member] != 0) revert MemberAlreadyAssigned(orgId, member);

        _memberRoles[orgId][member] = roleId;
        _organizations[orgId].memberCount++;

        emit RoleAssigned(orgId, member, roleId);

        // L1 sync — Type 11
        L1_MESSENGER_CONTRACT.sendToL1(
            abi.encode(uint8(11), orgId, member, roleId)
        );
    }

    function revokeRole(
        bytes32 orgId,
        address member
    ) external override onlyOrgOwnerOrPermission(orgId, PERM_MANAGE_MEMBERS) {
        if (_memberRoles[orgId][member] == 0) revert MemberNotAssigned(orgId, member);

        delete _memberRoles[orgId][member];
        _organizations[orgId].memberCount--;

        emit RoleRevoked(orgId, member);

        // L1 sync — Type 12
        L1_MESSENGER_CONTRACT.sendToL1(
            abi.encode(uint8(12), orgId, member)
        );
    }

    function getMemberRole(bytes32 orgId, address member) external view override returns (uint256) {
        return _memberRoles[orgId][member];
    }

    function hasPermission(bytes32 orgId, address member, uint256 permission) external view override returns (bool) {
        if (_organizations[orgId].owner == member) return true;
        uint256 roleId = _memberRoles[orgId][member];
        if (roleId == 0) return false;
        RoleData storage role = _roles[orgId][roleId];
        if ((role.permissions & PERM_ADMIN) != 0) return true;
        return (role.permissions & permission) != 0;
    }
}

Step 4: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add era-contracts-l1/system-contracts/contracts/Constants.sol \
        era-contracts-l1/system-contracts/contracts/interfaces/IEnterpriseIAM.sol \
        era-contracts-l1/system-contracts/contracts/EnterpriseIAM.sol
git commit -m "feat(sys): add EnterpriseIAM system contract (0x801A) + Constants registration"

---

Task 11: System Contracts — IIdentityVerifier + IdentityVerifier Selective Disclosure

Files:

• Modify: SYS/interfaces/IIdentityVerifier.sol:1-53

• Modify: SYS/IdentityVerifier.sol:1-299

Step 1: Add disclosure events and functions to IIdentityVerifier

After line 39 (CircuitVerifierSet event), add:

    // ── Selective Disclosure ─────────────────────────────────
    event DisclosurePolicyRegistered(bytes32 indexed policyId, bytes32 credentialType, uint8 circuitType);
    event SelectiveDisclosureVerified(address indexed identity, bytes32 indexed policyId);

    function registerDisclosurePolicy(bytes32 policyId, bytes32 credentialType, bytes32[] calldata requiredAttributes, uint8 circuitType) external;
    function verifySelectiveDisclosure(address identity, bytes32 policyId, uint256[2] calldata pA, uint256[2][2] calldata pB, uint256[2] calldata pC, uint256[] calldata publicInputs) external returns (bool);
    function hasValidDisclosure(address identity, bytes32 policyId) external view returns (bool);
    function getDisclosurePolicy(bytes32 policyId) external view returns (bytes32 credentialType, bytes32[] memory requiredAttributes, uint8 circuitType, bool active);

Step 2: Add disclosure storage and errors to IdentityVerifier.sol

After mapping(bytes32 => bool) private _usedProofs; (line 22), add:

    // ── Selective Disclosure Storage ──────────────────────────
    struct DisclosurePolicy {
        bytes32 credentialType;
        bytes32[] requiredAttributes;
        uint8 circuitType;
        bool active;
    }

    mapping(bytes32 => DisclosurePolicy) private _disclosurePolicies;
    mapping(address => mapping(bytes32 => bool)) private _disclosureResults;

After error InvalidProof(); (line 31), add:

    error PolicyAlreadyExists(bytes32 policyId);
    error PolicyNotFound(bytes32 policyId);
    error PolicyNotActive(bytes32 policyId);

Step 3: Add disclosure functions before the credit score section (before getPersonalCreditScore)

    // ── Selective Disclosure ──────────────────────────────────

    function registerDisclosurePolicy(
        bytes32 policyId,
        bytes32 credentialType,
        bytes32[] calldata requiredAttributes,
        uint8 circuitType
    ) external override onlyCallFromBootloader {
        if (_disclosurePolicies[policyId].active) revert PolicyAlreadyExists(policyId);
        if (_circuitVerifiers[circuitType] == address(0)) revert CircuitNotRegistered(circuitType);

        DisclosurePolicy storage policy = _disclosurePolicies[policyId];
        policy.credentialType = credentialType;
        policy.circuitType = circuitType;
        policy.active = true;
        for (uint256 i = 0; i < requiredAttributes.length; i++) {
            policy.requiredAttributes.push(requiredAttributes[i]);
        }

        emit DisclosurePolicyRegistered(policyId, credentialType, circuitType);
    }

    function verifySelectiveDisclosure(
        address identity,
        bytes32 policyId,
        uint256[2] calldata _pA,
        uint256[2][2] calldata _pB,
        uint256[2] calldata _pC,
        uint256[] calldata publicInputs
    ) external override onlySystemCall returns (bool) {
        if (!_didRegistry().isActive(identity)) revert IdentityNotActive(identity);

        DisclosurePolicy storage policy = _disclosurePolicies[policyId];
        if (!policy.active) revert PolicyNotActive(policyId);

        address verifierAddr = _circuitVerifiers[policy.circuitType];
        if (verifierAddr == address(0)) revert CircuitNotRegistered(policy.circuitType);

        bytes32 proofHash = keccak256(abi.encode(identity, policyId, _pA, _pB, _pC, publicInputs));
        if (_usedProofs[proofHash]) revert ProofAlreadyUsed(proofHash);

        (bool ok, bytes memory result) = verifierAddr.staticcall(
            abi.encodeWithSignature(
                "verifyProof(uint256[2],uint256[2][2],uint256[2],uint256[])",
                _pA, _pB, _pC, publicInputs
            )
        );
        if (!ok || result.length < 32) revert InvalidProof();
        bool valid = abi.decode(result, (bool));
        if (!valid) revert InvalidProof();

        _usedProofs[proofHash] = true;
        _disclosureResults[identity][policyId] = true;

        bytes32 complianceKey = keccak256(abi.encodePacked("SD_", policyId));
        _compliance[identity][complianceKey] = true;
        emit ComplianceUpdated(identity, complianceKey, true);
        emit SelectiveDisclosureVerified(identity, policyId);

        return true;
    }

    function hasValidDisclosure(address identity, bytes32 policyId) external view override returns (bool) {
        return _disclosureResults[identity][policyId];
    }

    function getDisclosurePolicy(bytes32 policyId) external view override returns (
        bytes32 credentialType, bytes32[] memory requiredAttributes, uint8 circuitType, bool active
    ) {
        DisclosurePolicy storage policy = _disclosurePolicies[policyId];
        return (policy.credentialType, policy.requiredAttributes, policy.circuitType, policy.active);
    }

Step 4: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add era-contracts-l1/system-contracts/contracts/interfaces/IIdentityVerifier.sol \
        era-contracts-l1/system-contracts/contracts/IdentityVerifier.sol
git commit -m "feat(sys): add selective disclosure to IdentityVerifier system contract"

---

Task 12: E2E Cross-Contract Tests

Files:

• Create: TEST/Phase5cE2E.t.sol

Step 1: Write cross-contract E2E test

Create contracts/test/Phase5cE2E.t.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

import "forge-std/Test.sol";
import "../src/did/DIDRegistryLocal.sol";
import "../src/did/CredentialRegistryLocal.sol";
import "../src/did/IdentityVerifierLocal.sol";
import "../src/did/EnterpriseIAMLocal.sol";
import "../src/did/MockGroth16Verifier.sol";

contract Phase5cE2ETest is Test {
    DIDRegistryLocal public didRegistry;
    CredentialRegistryLocal public credRegistry;
    IdentityVerifierLocal public verifier;
    EnterpriseIAMLocal public iam;
    MockGroth16Verifier public mockVerifier;

    address admin = makeAddr("admin");
    address orgOwner = makeAddr("orgOwner");
    address employee = makeAddr("employee");
    address guardian1 = makeAddr("guardian1");
    address guardian2 = makeAddr("guardian2");
    address guardian3 = makeAddr("guardian3");
    address newOwner = makeAddr("newOwner");

    bytes32 serviceHash = keccak256("service");
    bytes32 KYC_TYPE = keccak256("KYC");

    // Dummy proof data
    uint256[2] pA = [uint256(1), uint256(2)];
    uint256[2][2] pB = [[uint256(3), uint256(4)], [uint256(5), uint256(6)]];
    uint256[2] pC = [uint256(7), uint256(8)];

    function setUp() public {
        didRegistry = new DIDRegistryLocal();
        credRegistry = new CredentialRegistryLocal(address(didRegistry));
        verifier = new IdentityVerifierLocal(address(didRegistry), address(credRegistry), admin);
        iam = new EnterpriseIAMLocal(address(didRegistry));
        mockVerifier = new MockGroth16Verifier(true);

        vm.prank(admin);
        verifier.setCircuitVerifier(3, address(mockVerifier));

        _createDID(orgOwner);
        _createDID(employee);
    }

    function _createDID(address user) internal {
        bytes32[] memory methods = new bytes32[](1);
        methods[0] = keccak256(abi.encodePacked("pubkey_", user));
        vm.prank(user);
        didRegistry.createDID(methods, serviceHash);
    }

    function _publicInputs(uint256 val) internal pure returns (uint256[] memory) {
        uint256[] memory inputs = new uint256[](1);
        inputs[0] = val;
        return inputs;
    }

    // ── E2E: Recovery + IAM ─────────────────────────────────

    function test_E2E_recoveryThenOrgManagement() public {
        // 1. orgOwner sets up recovery
        address[] memory guardians = new address[](3);
        guardians[0] = guardian1;
        guardians[1] = guardian2;
        guardians[2] = guardian3;
        vm.prank(orgOwner);
        didRegistry.setRecovery(guardians, 2, 1 hours);

        // 2. orgOwner creates an organization
        bytes32 orgId = keccak256("acme");
        vm.prank(orgOwner);
        iam.createOrganization(orgId, orgOwner);

        // 3. orgOwner loses keys — guardians recover
        vm.prank(guardian1);
        didRegistry.initiateRecovery(orgOwner, newOwner);
        vm.prank(guardian2);
        didRegistry.approveRecovery(orgOwner);
        vm.warp(block.timestamp + 1 hours + 1);
        didRegistry.executeRecovery(orgOwner);

        // 4. Verify DID controller changed
        assertEq(didRegistry.resolveDID(orgOwner).controller, newOwner);

        // 5. Organization owner is still orgOwner (IAM level) — org data unchanged
        (, address owner,,) = iam.getOrganization(orgId);
        assertEq(owner, orgOwner);
    }

    // ── E2E: IAM + Credential + Verification ────────────────

    function test_E2E_orgIssuesCredentialThenVerifies() public {
        // 1. Create org
        bytes32 orgId = keccak256("bank");
        vm.prank(orgOwner);
        iam.createOrganization(orgId, orgOwner);

        // 2. Create issuer role with ISSUE + REVOKE permissions
        uint256 perms = iam.PERM_ISSUE_CREDENTIAL() | iam.PERM_REVOKE_CREDENTIAL();
        vm.prank(orgOwner);
        uint256 roleId = iam.createRole(orgId, keccak256("issuer"), perms);

        // 3. Assign employee to issuer role
        vm.prank(orgOwner);
        iam.assignRole(orgId, employee, roleId);
        assertTrue(iam.hasPermission(orgId, employee, iam.PERM_ISSUE_CREDENTIAL()));

        // 4. Employee (as DID holder) issues KYC credential
        _createDID(makeAddr("subject2"));
        vm.prank(employee);
        bytes32 credId = credRegistry.issueCredential(
            makeAddr("subject2"),
            KYC_TYPE,
            keccak256("kyc_data"),
            uint64(block.timestamp + 365 days)
        );
        assertTrue(credRegistry.isCredentialValid(credId));
    }

    // ── E2E: Selective Disclosure + Compliance ───────────────

    function test_E2E_selectiveDisclosureSetsCompliance() public {
        // 1. Register age proof policy
        bytes32 policyId = keccak256("AGE_18_PLUS");
        bytes32[] memory attrs = new bytes32[](1);
        attrs[0] = keccak256("age");
        vm.prank(admin);
        verifier.registerDisclosurePolicy(policyId, KYC_TYPE, attrs, 3);

        // 2. Employee proves age >= 18
        _createDID(makeAddr("user1"));
        bool result = verifier.verifySelectiveDisclosure(
            makeAddr("user1"), policyId, pA, pB, pC, _publicInputs(18)
        );
        assertTrue(result);

        // 3. Check compliance key was set
        bytes32 complianceKey = keccak256(abi.encodePacked("SD_", policyId));
        assertTrue(verifier.checkCompliance(makeAddr("user1"), complianceKey));

        // 4. Check disclosure result
        assertTrue(verifier.hasValidDisclosure(makeAddr("user1"), policyId));
    }

    // ── E2E: Full Lifecycle ─────────────────────────────────

    function test_E2E_fullLifecycle() public {
        // 1. Create DID → 2. Set recovery → 3. Create org → 4. Assign roles
        // 5. Issue credential → 6. Verify via selective disclosure
        // 7. Recover identity → 8. New controller still verified

        // Step 1-2: DID + Recovery
        address user = makeAddr("fullUser");
        _createDID(user);
        address[] memory guardians = new address[](2);
        guardians[0] = guardian1;
        guardians[1] = guardian2;
        vm.prank(user);
        didRegistry.setRecovery(guardians, 2, 1 hours);

        // Step 3-4: Org + Role
        bytes32 orgId = keccak256("fullOrg");
        vm.prank(orgOwner);
        iam.createOrganization(orgId, orgOwner);
        vm.prank(orgOwner);
        uint256 roleId = iam.createRole(orgId, keccak256("member"), iam.PERM_VIEW_REPORTS());
        vm.prank(orgOwner);
        iam.assignRole(orgId, user, roleId);
        assertTrue(iam.hasPermission(orgId, user, iam.PERM_VIEW_REPORTS()));

        // Step 5: Credential
        vm.prank(orgOwner);
        credRegistry.issueCredential(user, KYC_TYPE, keccak256("data"), uint64(block.timestamp + 365 days));

        // Step 6: Selective disclosure
        bytes32 policyId = keccak256("AGE_CHECK");
        bytes32[] memory attrs = new bytes32[](1);
        attrs[0] = keccak256("age");
        vm.prank(admin);
        verifier.registerDisclosurePolicy(policyId, KYC_TYPE, attrs, 3);
        verifier.verifySelectiveDisclosure(user, policyId, pA, pB, pC, _publicInputs(99));
        assertTrue(verifier.hasValidDisclosure(user, policyId));

        // Step 7: Recovery
        vm.prank(guardian1);
        didRegistry.initiateRecovery(user, newOwner);
        vm.prank(guardian2);
        didRegistry.approveRecovery(user);
        vm.warp(block.timestamp + 1 hours + 1);
        didRegistry.executeRecovery(user);
        assertEq(didRegistry.resolveDID(user).controller, newOwner);

        // Step 8: Disclosure and IAM membership still valid (identity address unchanged)
        assertTrue(verifier.hasValidDisclosure(user, policyId));
        assertTrue(iam.hasPermission(orgId, user, iam.PERM_VIEW_REPORTS()));
    }
}

Step 2: Run all tests

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test --match-contract Phase5cE2ETest -v Expected: All 4 E2E tests pass

Step 3: Commit

cd /Users/judybaby/CodeBase/github/Layer2
git add contracts/test/Phase5cE2E.t.sol
git commit -m "test(e2e): add Phase 5c cross-contract E2E tests"

---

Task 13: Full Regression + Compile System Contracts

Files: All existing test files

Step 1: Run full Foundry test suite

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test -v Expected: All tests pass (existing ~58 + new ~59 = ~117 total)

Step 2: Compile system contracts

Run:

cd /Users/judybaby/CodeBase/github/Layer2/era-contracts-l1/system-contracts
nvm use 20
yarn preprocess:system-contracts

Expected: Preprocessing completes (copies modified DIDRegistry, IdentityVerifier, and new EnterpriseIAM to contracts-preprocessed/)

Note: Full yarn build for system contracts may require additional setup (hardhat-zksync-solc, zksolc). If it fails on compiler, that's expected in local dev — the preprocessed files are the key output.

Step 3: Verify EnterpriseIAM appears in contracts-preprocessed

Run: ls /Users/judybaby/CodeBase/github/Layer2/era-contracts-l1/system-contracts/contracts-preprocessed/EnterpriseIAM.sol Expected: File exists

---

Task 14: Update dev-log + Final Commit

Files:

• Modify: /Users/judybaby/CodeBase/github/Layer2/docs/dev-log.md

Step 1: Add Phase 5c entry to dev-log

Append to docs/dev-log.md:

---

## Phase 5c: 社会恢复 + 企业 IAM + 选择性披露 (2026-03-06)

### 完成内容

**Part 1: 社会恢复 (DIDRegistry 0x8017)**
- N-of-M guardian 恢复 + 24h 时间锁
- setRecovery / initiateRecovery / approveRecovery / executeRecovery / cancelRecovery
- L1 sync: Type 8 (RecoveryInitiated), Type 9 (RecoveryExecuted)
- 20 Foundry 测试

**Part 2: 企业 IAM (EnterpriseIAM 0x801A)**
- 新系统合约: 组织管理 + 角色 + 权限位图 (uint256, 8 权限常量)
- createOrganization / createRole / assignRole / revokeRole / hasPermission
- DIDRegistry 集成: 组织 DID 需活跃, 创建者需 controller/delegate
- L1 sync: Type 10 (OrgCreated), Type 11 (RoleAssigned), Type 12 (RoleRevoked)
- 22 Foundry 测试

**Part 3: 选择性披露 (IdentityVerifier 0x8019)**
- ZK 属性级证明 (证明年龄 >= 18 而不暴露出生日期)
- DisclosurePolicy 结构 + circuitType 3-5 (age/income/region)
- registerDisclosurePolicy / verifySelectiveDisclosure / hasValidDisclosure
- 复用 Groth16 基础设施 (_circuitVerifiers, _usedProofs)
- 验证成功自动设置 compliance key (SD_<policyId>)
- 13 Foundry 测试

**E2E 测试**: 4 个跨合约集成测试 (recovery+IAM, IAM+credential, disclosure+compliance, full lifecycle)

### 系统合约地址总表
| 地址 | 合约 | Phase |
|------|------|-------|
| 0x8016 | OracleHub | P2 |
| 0x8017 | DIDRegistry | P5a + P5c |
| 0x8018 | CredentialRegistry | P5a |
| 0x8019 | IdentityVerifier | P5a/b + P5c |
| 0x801A | EnterpriseIAM | P5c |

Step 2: Commit everything

cd /Users/judybaby/CodeBase/github/Layer2
git add docs/dev-log.md
git commit -m "docs: Phase 5c completion — social recovery + enterprise IAM + selective disclosure"

---

Summary

Task	Description	Tests	Files
1	IDIDRegistryLocal recovery interface	—	1 modify
2	DIDRegistryLocal recovery impl	—	1 modify
3	Social recovery tests	20	1 create
4	IEnterpriseIAMLocal + EnterpriseIAMLocal	—	2 create
5	Enterprise IAM tests	22	1 create
6	IdentityVerifierLocal disclosure impl	—	1 modify
7	Selective disclosure tests	13	1 create
8	IDIDRegistry system interface	—	1 modify
9	DIDRegistry system contract recovery	—	1 modify
10	IEnterpriseIAM + EnterpriseIAM sys + Constants	—	3 create, 1 modify
11	IIdentityVerifier + IdentityVerifier disclosure	—	2 modify
12	E2E cross-contract tests	4	1 create
13	Full regression + compile system contracts	—	—
14	Dev-log update	—	1 modify
Total		~59 new tests	9 create, 8 modify