ERC-8089: Smart Contract Lifecycle Registry

/// @title Smart Contract Lifecycle Registry
pragma solidity ^0.8.0;

interface IContractRegistry {
    enum ContractStatus { Default, Active, Deprecated, Frozen, Terminated }

    struct ContractMetadata {
        ContractStatus status;
        string extraData;
        uint256 statusUpdateTimestamp;
    }

    // MUST trigger when a new contract is added to the registry
    event ContractRegistered(address indexed contractAddress);
  
    // MUST trigger when a registered contract’s status field is modified
    event ContractStatusModified(address indexed contractAddress, ContractStatus oldStatus, ContractStatus newStatus);
  
    // MUST trigger when a registered contract’s extraData field is modified
    event ContractExtraDataModified(address indexed contractAddress, string newExtraData, string newExtraData);
  
    // MUST trigger when a contract is removed from the registry
    event ContractRemoved(address indexed contractAddress);

    // MUST be called only by AUTHORIZED users (e.g., the registry owner) to add a new contract to the registry and MUST emit the ContractRegistered event
    function registerContract(address contractAddress, ContractStatus status, string memory extraData) external;
  
    // MUST be called only by AUTHORIZED users to modify a registered contract’s status and MUST emit the ContractStatusModified event
    function modifyContractStatus(address contractAddress, ContractStatus newStatus) external;
  
    // MUST be called only by AUTHORIZED users to modify a registered contract’s extraData and MUST emit the ContractExtraDataModified event
    function modifyContractExtraData(address contractAddress, string newExtraData) external;
  
    // MUST called only by AUTHORIZED users to remove a contract from the registry and MUST emit the ContractRemoved event
    function removeContract(address contractAddress) external;
  
    // Provides public read-only access to a contract’s metadata to inspect its current status, extraData, and timestamps
    function getContractMetadata(address contractAddress) external view returns (ContractMetadata memory);
  
    // Returns a list of all registered contract addresses, enabling to enumerate the entire inventory of contracts managed by the registry
    function getAllContracts() external view returns (address[] memory);
}

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

/// @title EIP8089 Implementation
/// @notice Implementation of EIP-8089 Smart Contract Lifecycle Registry Standard
/// @dev This registry allows operators to record and update metadata about contracts, including their operational status
contract ContractRegistry is Ownable {
    using EnumerableSet for EnumerableSet.AddressSet;

    /// @notice Status of a registered contract
    /// @dev Used to track the lifecycle status of registered contracts
    enum ContractStatus { 
        Default,      /// Initial or reset state
        Active,       /// Contract is operational
        Deprecated,   /// Contract is outdated but still functional
        Frozen,       /// Contract operations are temporarily suspended but recoverable
        Terminated   /// Contract is permanently disabled and not recoverable
    }

    /// @notice Metadata associated with a registered contract
    /// @dev Contains status, extra data, and timestamp information
    struct ContractMetadata {
        ContractStatus status;              /// Current status of the contract
        string extraData;                   /// Additional information about the contract
        uint256 statusUpdateTimestamp;      /// Timestamp of last status update
    }

    /// @dev Mapping of contract addresses to their metadata
    mapping(address => ContractMetadata) private _metadata;
    
    /// @dev Set of all registered contract addresses
    EnumerableSet.AddressSet private _contracts;

    /// @notice Emitted when a new contract is registered
    /// @param contractAddress The address of the registered contract
    event ContractRegistered(address indexed contractAddress);
    
    /// @notice Emitted when a contract's status is modified
    /// @param contractAddress The address of the contract
    /// @param oldStatus The previous status of the contract
    /// @param newStatus The new status of the contract
    event ContractStatusModified(address indexed contractAddress, ContractStatus oldStatus, ContractStatus newStatus);
    
    /// @notice Emitted when a contract's extra data is modified
    /// @param contractAddress The address of the contract
    /// @param oldExtraData The previous extra data
    /// @param newExtraData The new extra data
    event ContractExtraDataModified(address indexed contractAddress, string oldExtraData, string newExtraData);
    
    /// @notice Emitted when a contract is removed from the registry
    /// @param contractAddress The address of the removed contract
    event ContractRemoved(address indexed contractAddress);

    /// @dev Maximum length for extraData field (256 bytes)
    uint256 private constant MAX_EXTRADATA_LENGTH = 256;

    /// @notice Constructs the ContractRegistry contract
    /// @param initialOwner The address that will be set as the owner of the contract
    constructor(address initialOwner) Ownable(initialOwner) {}

    /// @dev Private function to update contract status and emit ContractStatusModified event
    /// @param contractAddress The address of the contract to update
    /// @param newStatus The new status to assign to the contract
    function _modifyContractStatus(address contractAddress, ContractStatus newStatus) private {
        ContractStatus oldStatus = _metadata[contractAddress].status;
        _metadata[contractAddress].status = newStatus;
        _metadata[contractAddress].statusUpdateTimestamp = block.timestamp;

        emit ContractStatusModified(contractAddress, oldStatus, newStatus);
    }

    /// @dev Private function to update extra data field and emit ContractExtraDataModified event
    /// @param contractAddress The address of the contract to update
    /// @param newExtraData The new extra data to assign to the contract
    function _modifyContractExtraData(address contractAddress, string memory newExtraData) private {
        string memory oldExtraData = _metadata[contractAddress].extraData;

        require(bytes(newExtraData).length <= MAX_EXTRADATA_LENGTH, "ExtraData too long");
        _metadata[contractAddress].extraData = newExtraData;

        emit ContractExtraDataModified(contractAddress, oldExtraData, newExtraData);
    }

    /// @notice Registers a new contract in the registry
    /// @dev Only callable by the owner
    /// @param contractAddress The address of the contract to register
    /// @param newStatus The initial status to assign to the contract
    /// @param newExtraData Additional information about the contract
    function registerContract(
        address contractAddress, 
        ContractStatus newStatus, 
        string calldata newExtraData
    ) public onlyOwner {
        require(contractAddress != address(0), "Invalid address");
        require(!_contracts.contains(contractAddress), "Contract already registered");
        _contracts.add(contractAddress);
        _modifyContractStatus(contractAddress, newStatus);
        _modifyContractExtraData(contractAddress, newExtraData);
        emit ContractRegistered(contractAddress);
    }

    /// @notice Updates the status of a registered contract
    /// @dev Only callable by the owner
    /// @param contractAddress The address of the contract to update
    /// @param newStatus The new status to assign to the contract
    function modifyContractStatus(
        address contractAddress, 
        ContractStatus newStatus
    ) public onlyOwner {
        require(_contracts.contains(contractAddress), "Contract not registered");
        require(newStatus != ContractStatus.Default, "Invalid contract status");
        _modifyContractStatus(contractAddress, newStatus);
    }

    /// @notice Updates the extra data of a registered contract
    /// @dev Only callable by the owner
    /// @param contractAddress The address of the contract to update
    /// @param newExtraData The new extra data to assign to the contract
    function modifyContractExtraData(
        address contractAddress, 
        string calldata newExtraData
    ) public onlyOwner {
        require(_contracts.contains(contractAddress), "Contract not registered");
        _modifyContractExtraData(contractAddress, newExtraData);
    }

    /// @notice Removes a contract from the registry
    /// @dev Only callable by the owner. Resets contract metadata to default values.
    /// @param contractAddress The address of the contract to remove
    function removeContract(address contractAddress) public onlyOwner {
        require(_contracts.contains(contractAddress), "Contract not registered");
        _contracts.remove(contractAddress);
        _modifyContractStatus(contractAddress, ContractStatus.Default);
        _modifyContractExtraData(contractAddress, "");
        emit ContractRemoved(contractAddress);
    }

    /// @notice Retrieves the metadata for a registered contract
    /// @dev Reverts if the contract is not registered
    /// @param contractAddress The address of the contract
    /// @return The metadata associated with the contract
    function getContractMetadata(address contractAddress) public view returns (ContractMetadata memory) {
        require(_contracts.contains(contractAddress), "Contract not registered");
        return _metadata[contractAddress];
    }

    /// @notice Retrieves all registered contract addresses
    /// @return An array of all registered contract addresses
    function getAllContracts() public view returns (address[] memory) {
        return _contracts.values();
    }
}