Contract Address Details

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.24;

import {IAllowedAdmin} from "./IAllowedAdmin.sol";
import {
    ListAlreadyRegistered,
    ListNotRegistered,
    OnlyListOwner,
    ListOwnerIsZeroAddress,
    OwnableInvalidOwner
} from "./Constants.sol";

/**
 * @title Allowed
 * @notice Multi-list registry with hash-based namespacing.
 *         Public good contract — anyone can register a list with keccak256(namespace).
 *         Each list has its own owner with 2-step ownership transfer.
 *
 * Design:
 *   - List IDs are bytes32 hashes (e.g., keccak256("Name of List"))
 *   - Registration is open — anyone can register any hash with a specified owner
 *   - Each list owner can add/remove addresses from their list only
 *   - 2-step ownership transfer pattern (initiate → accept) for safety
 *   - No global admin — fully decentralized per-list management
 *
 * Use cases:
 *   - Token distribution allowed lists
 *   - Access control lists for DeFi protocols
 *   - Airdrop eligibility tracking
 *   - Any scenario requiring isolated, owner-managed address sets
 */
contract Allowed is IAllowedAdmin {
    // ──────────────────────────────────────────────
    // Storage
    // ──────────────────────────────────────────────

    /// @dev listId => account => isListed
    mapping(bytes32 => mapping(address => bool)) private _listed;

    /// @dev listId => owner address
    mapping(bytes32 => address) private _listOwners;

    /// @dev listId => pending owner address (for 2-step transfer)
    mapping(bytes32 => address) private _pendingListOwners;

    // ──────────────────────────────────────────────
    // Constructor
    // ──────────────────────────────────────────────

    /// @dev Empty constructor — all lists are registered post-deploy
    constructor() {}

    // ──────────────────────────────────────────────
    // Registration
    // ──────────────────────────────────────────────

    /**
     * @notice Registers a new list with the specified owner.
     *         Anyone can register any hash. First-come, first-served.
     * @param listId The keccak256 hash identifying this list
     * @param owner The address that will own and manage this list
     */
    function registerList(bytes32 listId, address owner) external {
        if (_listOwners[listId] != address(0)) {
            revert ListAlreadyRegistered(listId);
        }
        if (owner == address(0)) {
            revert ListOwnerIsZeroAddress();
        }

        _listOwners[listId] = owner;
        emit ListRegistered({listId: listId, owner: owner});
    }

    // ──────────────────────────────────────────────
    // List queries
    // ──────────────────────────────────────────────

    /**
     * @notice Returns whether the given address is listed in the specified list.
     * @param listId The list to check
     * @param account The address to check
     * @return True if listed, false otherwise
     */
    function isListed(bytes32 listId, address account) external view returns (bool) {
        return _listed[listId][account];
    }

    /**
     * @notice Returns the owner of the specified list.
     * @param listId The list to query
     * @return The owner address (zero if not registered)
     */
    function getListOwner(bytes32 listId) external view returns (address) {
        return _listOwners[listId];
    }

    /**
     * @notice Returns the pending owner of the specified list (2-step transfer).
     * @param listId The list to query
     * @return The pending owner address (zero if no pending transfer)
     */
    function getPendingListOwner(bytes32 listId) external view returns (address) {
        return _pendingListOwners[listId];
    }

    // ──────────────────────────────────────────────
    // List management (owner only)
    // ──────────────────────────────────────────────

    /**
     * @notice Sets the listed status for a given address. Owner only.
     * @param listId The list to modify
     * @param account The address to update
     * @param status The new listed status
     */
    function setListed(bytes32 listId, address account, bool status) external {
        _checkCallerIsOwner(listId);
        _listed[listId][account] = status;
        emit ListUpdated({listId: listId, account: account, status: status});
    }

    /**
     * @notice Sets the listed status for multiple addresses at once. Owner only.
     * @param listId The list to modify
     * @param accounts Array of addresses to update
     * @param status Listed status to apply to all addresses
     * @dev For large lists, may need to be called multiple times in batches to avoid gas limits.
     *      Gas cost: ~26,000 per address. At 30M gas limit, max ~1,150 addresses per transaction.
     *      Recommended batch size: 300-500 addresses per transaction.
     */
    function setListedBatch(bytes32 listId, address[] calldata accounts, bool status) external {
        _checkCallerIsOwner(listId);
        uint256 length = accounts.length;
        for (uint256 i; i < length;) {
            _listed[listId][accounts[i]] = status;
            emit ListUpdated({listId: listId, account: accounts[i], status: status});
            unchecked { ++i; }
        }
    }

    // ──────────────────────────────────────────────
    // Ownership management (2-step transfer)
    // ──────────────────────────────────────────────

    /**
     * @notice Initiates ownership transfer for a list. Current owner only.
     *         The new owner must call `acceptListOwnership` to complete the transfer.
     * @param listId The list to transfer
     * @param newOwner The address to transfer ownership to
     */
    function transferListOwnership(bytes32 listId, address newOwner) external {
        _checkCallerIsOwner(listId);
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }

        _pendingListOwners[listId] = newOwner;
        emit ListOwnershipTransferStarted({listId: listId, previousOwner: msg.sender, newOwner: newOwner});
    }

    /**
     * @notice Completes ownership transfer by accepting as the pending owner.
     * @param listId The list to accept ownership of
     */
    function acceptListOwnership(bytes32 listId) external {
        address pendingOwner = _pendingListOwners[listId];
        if (msg.sender != pendingOwner) {
            revert OwnableInvalidOwner(msg.sender);
        }

        address previousOwner = _listOwners[listId];
        delete _pendingListOwners[listId];
        _listOwners[listId] = msg.sender;

        emit ListOwnershipTransferred({listId: listId, previousOwner: previousOwner, newOwner: msg.sender});
    }

    /**
     * @notice Cancels a pending ownership transfer. Current owner only.
     * @param listId The list to cancel transfer for
     */
    function cancelListOwnershipTransfer(bytes32 listId) external {
        _checkCallerIsOwner(listId);
        delete _pendingListOwners[listId];
    }

    // ──────────────────────────────────────────────
    // Internal helpers
    // ──────────────────────────────────────────────

    /**
     * @dev Reverts if msg.sender is not the owner of the list.
     */
    function _checkCallerIsOwner(bytes32 listId) private view {
        address owner = _listOwners[listId];
        if (owner == address(0)) {
            revert ListNotRegistered(listId);
        }
        if (msg.sender != owner) {
            revert OnlyListOwner(listId, msg.sender);
        }
    }
}
        

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.24;

/**
 * @title IAllowed
 * @notice Client interface for the Allowed multi-list registry.
 *         Consumers (like ProveX) should reference this interface to query list status.
 *         This interface contains only read operations — no admin functions.
 *
 * Design rationale:
 *   - Minimal surface area for client contracts
 *   - No exposure to admin operations (ownership, list management)
 *   - Clients cannot accidentally call admin functions
 *   - Clear separation of concerns: query vs. management
 */
interface IAllowed {
    /**
     * @notice Returns whether the given address is listed in the specified list.
     * @param listId The list to check
     * @param account The address to check
     * @return True if listed, false otherwise
     */
    function isListed(bytes32 listId, address account) external view returns (bool);

    /**
     * @notice Returns the owner of the specified list.
     * @param listId The list to query
     * @return The owner address (zero if not registered)
     */
    function getListOwner(bytes32 listId) external view returns (address);

    /**
     * @notice Returns the pending owner of the specified list (2-step transfer).
     * @param listId The list to query
     * @return The pending owner address (zero if no pending transfer)
     */
    function getPendingListOwner(bytes32 listId) external view returns (address);
}
          

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.24;

import {IAllowed} from "./IAllowed.sol";

/**
 * @title IAllowedAdmin
 * @notice Complete admin interface for the Allowed multi-list registry.
 *         Extends IAllowed with registration, list management, and ownership operations.
 *         List owners and operators should reference this interface.
 *
 * Design rationale:
 *   - Extends IAllowed (clients get read-only, admins get full control)
 *   - Exposes all registry operations (registration, list updates, ownership)
 *   - Single source of truth for the complete Allowed API
 *   - Enforces interface compliance on the Allowed implementation
 */
interface IAllowedAdmin is IAllowed {
    // ──────────────────────────────────────────────
    // Events
    // ──────────────────────────────────────────────

    /// @dev Emitted when a new list is registered.
    event ListRegistered(bytes32 indexed listId, address indexed owner);

    /// @dev Emitted when list ownership transfer is initiated (2-step).
    event ListOwnershipTransferStarted(bytes32 indexed listId, address indexed previousOwner, address indexed newOwner);

    /// @dev Emitted when list ownership transfer is completed.
    event ListOwnershipTransferred(bytes32 indexed listId, address indexed previousOwner, address indexed newOwner);

    /// @dev Emitted when a list entry is updated.
    event ListUpdated(bytes32 indexed listId, address indexed account, bool status);

    // ──────────────────────────────────────────────
    // Registration
    // ──────────────────────────────────────────────

    /**
     * @notice Registers a new list with the specified owner.
     *         Anyone can register any hash. First-come, first-served.
     * @param listId The keccak256 hash identifying this list
     * @param owner The address that will own and manage this list
     */
    function registerList(bytes32 listId, address owner) external;

    // ──────────────────────────────────────────────
    // List management (owner only)
    // ──────────────────────────────────────────────

    /**
     * @notice Sets the listed status for a given address. Owner only.
     * @param listId The list to modify
     * @param account The address to update
     * @param status The new listed status
     */
    function setListed(bytes32 listId, address account, bool status) external;

    /**
     * @notice Sets the listed status for multiple addresses at once. Owner only.
     * @param listId The list to modify
     * @param accounts Array of addresses to update
     * @param status Listed status to apply to all addresses
     */
    function setListedBatch(bytes32 listId, address[] calldata accounts, bool status) external;

    // ──────────────────────────────────────────────
    // Ownership management (2-step transfer)
    // ──────────────────────────────────────────────

    /**
     * @notice Initiates ownership transfer for a list. Current owner only.
     *         The new owner must call `acceptListOwnership` to complete the transfer.
     * @param listId The list to transfer
     * @param newOwner The address to transfer ownership to
     */
    function transferListOwnership(bytes32 listId, address newOwner) external;

    /**
     * @notice Completes ownership transfer by accepting as the pending owner.
     * @param listId The list to accept ownership of
     */
    function acceptListOwnership(bytes32 listId) external;

    /**
     * @notice Cancels a pending ownership transfer. Current owner only.
     * @param listId The list to cancel transfer for
     */
    function cancelListOwnershipTransfer(bytes32 listId) external;
}
          

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.24;

// ──────────────────────────────────────────────
// Custom errors — Allowed registry only
// ──────────────────────────────────────────────

/// @dev List with this ID is already registered.
error ListAlreadyRegistered(bytes32 listId);

/// @dev List with this ID is not registered.
error ListNotRegistered(bytes32 listId);

/// @dev Caller is not the owner of this list.
error OnlyListOwner(bytes32 listId, address caller);

/// @dev List owner address is zero.
error ListOwnerIsZeroAddress();

/// @dev Invalid owner address for ownership transfer.
error OwnableInvalidOwner(address owner);