ZoneTIP403Registry.sol

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

import { ITIP403Registry } from "../interfaces/ITIP403Registry.sol";
import { ITempoState, TEMPO_STATE, TIP403_REGISTRY_ADDRESS } from "./IZone.sol";

/// @title ZoneTIP403Registry
/// @notice Read-only zone mirror of Tempo's TIP-403 registry
/// @dev Deployed at the same address as the Tempo TIP-403 registry. Queries are
///      answered by reading Tempo storage through `TempoState` at the latest
///      finalized Tempo block. Mutating methods revert on the zone.
contract ZoneTIP403Registry is ITIP403Registry {

    uint64 internal constant REJECT_ALL_POLICY_ID = 0;
    uint64 internal constant ALLOW_ALL_POLICY_ID = 1;

    // TIP403Registry storage layout on Tempo:
    //   slot 0: policyIdCounter
    //   slot 1: policyRecords (mapping(uint64 => PolicyRecord))
    //   slot 2: policySet (mapping(uint64 => mapping(address => bool)))
    uint256 internal constant POLICY_ID_COUNTER_SLOT = 0;
    uint256 internal constant POLICY_RECORDS_SLOT = 1;
    uint256 internal constant POLICY_SET_SLOT = 2;

    ITempoState internal constant TEMPO_STATE_CONTRACT = ITempoState(TEMPO_STATE);

    error ReadOnlyRegistry();

    function policyIdCounter() public view returns (uint64) {
        return _policyIdCounter();
    }

    function policyExists(uint64 policyId) public view returns (bool) {
        if (policyId <= ALLOW_ALL_POLICY_ID) {
            return true;
        }

        return policyId < _policyIdCounter();
    }

    function policyData(uint64 policyId)
        public
        view
        returns (PolicyType policyType, address admin)
    {
        if (policyId == REJECT_ALL_POLICY_ID) {
            return (PolicyType.WHITELIST, address(0));
        }
        if (policyId == ALLOW_ALL_POLICY_ID) {
            return (PolicyType.BLACKLIST, address(0));
        }

        return _getPolicyData(policyId);
    }

    function createPolicy(address, PolicyType) external pure returns (uint64) {
        revert ReadOnlyRegistry();
    }

    function createPolicyWithAccounts(
        address,
        PolicyType,
        address[] calldata
    )
        external
        pure
        returns (uint64)
    {
        revert ReadOnlyRegistry();
    }

    function setPolicyAdmin(uint64, address) external pure {
        revert ReadOnlyRegistry();
    }

    function modifyPolicyWhitelist(uint64, address, bool) external pure {
        revert ReadOnlyRegistry();
    }

    function modifyPolicyBlacklist(uint64, address, bool) external pure {
        revert ReadOnlyRegistry();
    }

    function isAuthorized(uint64 policyId, address user) public view returns (bool) {
        if (policyId <= ALLOW_ALL_POLICY_ID) {
            return policyId == ALLOW_ALL_POLICY_ID;
        }

        (PolicyType policyType,) = _getPolicyData(policyId);
        if (policyType == PolicyType.COMPOUND) {
            if (!isAuthorizedSender(policyId, user)) {
                return false;
            }

            return isAuthorizedRecipient(policyId, user);
        }

        return _isAuthorizedSimple(policyId, user, policyType);
    }

    function createCompoundPolicy(uint64, uint64, uint64)
        external
        pure
        returns (uint64)
    {
        revert ReadOnlyRegistry();
    }

    function isAuthorizedSender(uint64 policyId, address user) public view returns (bool) {
        if (policyId <= ALLOW_ALL_POLICY_ID) {
            return policyId == ALLOW_ALL_POLICY_ID;
        }

        (PolicyType policyType,) = _getPolicyData(policyId);
        if (policyType == PolicyType.COMPOUND) {
            (uint64 senderPolicyId,,) = _getCompoundPolicyData(policyId);
            return isAuthorized(senderPolicyId, user);
        }

        return _isAuthorizedSimple(policyId, user, policyType);
    }

    function isAuthorizedRecipient(uint64 policyId, address user) public view returns (bool) {
        if (policyId <= ALLOW_ALL_POLICY_ID) {
            return policyId == ALLOW_ALL_POLICY_ID;
        }

        (PolicyType policyType,) = _getPolicyData(policyId);
        if (policyType == PolicyType.COMPOUND) {
            (, uint64 recipientPolicyId,) = _getCompoundPolicyData(policyId);
            return isAuthorized(recipientPolicyId, user);
        }

        return _isAuthorizedSimple(policyId, user, policyType);
    }

    function isAuthorizedMintRecipient(uint64 policyId, address user)
        public
        view
        returns (bool)
    {
        if (policyId <= ALLOW_ALL_POLICY_ID) {
            return policyId == ALLOW_ALL_POLICY_ID;
        }

        (PolicyType policyType,) = _getPolicyData(policyId);
        if (policyType == PolicyType.COMPOUND) {
            (,, uint64 mintRecipientPolicyId) = _getCompoundPolicyData(policyId);
            return isAuthorized(mintRecipientPolicyId, user);
        }

        return _isAuthorizedSimple(policyId, user, policyType);
    }

    function compoundPolicyData(uint64 policyId)
        external
        view
        returns (uint64 senderPolicyId, uint64 recipientPolicyId, uint64 mintRecipientPolicyId)
    {
        (PolicyType policyType,) = policyData(policyId);
        if (policyType != PolicyType.COMPOUND) revert IncompatiblePolicyType();

        return _getCompoundPolicyData(policyId);
    }

    function _policyIdCounter() internal view returns (uint64) {
        return uint64(uint256(_readTempoStorage(bytes32(POLICY_ID_COUNTER_SLOT))));
    }

    function _getPolicyData(uint64 policyId)
        internal
        view
        returns (PolicyType policyType, address admin)
    {
        bytes32 raw = _readTempoStorage(_policyRecordBaseSlot(policyId));
        uint8 rawPolicyType = uint8(uint256(raw));
        if (rawPolicyType > uint8(PolicyType.COMPOUND)) revert InvalidPolicyType();

        policyType = PolicyType(rawPolicyType);
        admin = address(uint160(uint256(raw) >> 8));

        // Match the L1 registry's "default slot means maybe-missing" check.
        if (
            rawPolicyType == uint8(PolicyType.WHITELIST) && admin == address(0)
                && policyId >= _policyIdCounter()
        ) {
            revert PolicyNotFound();
        }
    }

    function _getCompoundPolicyData(uint64 policyId)
        internal
        view
        returns (uint64 senderPolicyId, uint64 recipientPolicyId, uint64 mintRecipientPolicyId)
    {
        bytes32 raw = _readTempoStorage(bytes32(uint256(_policyRecordBaseSlot(policyId)) + 1));
        senderPolicyId = uint64(uint256(raw));
        recipientPolicyId = uint64(uint256(raw) >> 64);
        mintRecipientPolicyId = uint64(uint256(raw) >> 128);
    }

    function _isAuthorizedSimple(uint64 policyId, address user, PolicyType policyType)
        internal
        view
        returns (bool)
    {
        if (policyType == PolicyType.COMPOUND) revert IncompatiblePolicyType();

        bool inSet = _readPolicySet(policyId, user);
        return policyType == PolicyType.WHITELIST ? inSet : !inSet;
    }

    function _readPolicySet(uint64 policyId, address user) internal view returns (bool) {
        bytes32 policySetBase = keccak256(abi.encode(policyId, uint256(POLICY_SET_SLOT)));
        bytes32 userSlot = keccak256(abi.encode(user, policySetBase));
        return uint8(uint256(_readTempoStorage(userSlot)) & 0xff) != 0;
    }

    function _policyRecordBaseSlot(uint64 policyId) internal pure returns (bytes32) {
        return keccak256(abi.encode(policyId, uint256(POLICY_RECORDS_SLOT)));
    }

    function _readTempoStorage(bytes32 slot) internal view returns (bytes32) {
        return TEMPO_STATE_CONTRACT.readTempoStorageSlot(TIP403_REGISTRY_ADDRESS, slot);
    }

}