Controller

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

contract Controller {
    address public owner;
    address public token = 0x44709a920fCcF795fbC57BAA433cc3dd53C44DbE;

    string public manifest = "hunt.dappradar.com - Controller v1";
    string public hint = "---test---";

    mapping(bytes32 => address) private _engines;

    event EngineUpdated(bytes32 indexed name, address indexed previous, address indexed current, address setter);
    event TokenUpdated(address indexed previous, address indexed current, address setter);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event ManifestUpdated(string previous, string current, address setter); 
    event HintUpdated(string previous, string current, address setter);     

    modifier onlyOwner() {
        require(msg.sender == owner, "not owner");
        _;
    }

    constructor() {
        owner = msg.sender;
        emit OwnershipTransferred(address(0), msg.sender);
    }

    function setEngine(bytes32 name, address engineAddr) external onlyOwner {
        _setEngine(name, engineAddr);
    }

    function _setEngine(bytes32 name, address engineAddr) internal {
        address prev = _engines[name];
        _engines[name] = engineAddr;
        emit EngineUpdated(name, prev, engineAddr, msg.sender);
    }

    function setEngineByString(string calldata name, address engineAddr) external onlyOwner {
        bytes32 k = _toBytes32(name);
        _setEngine(k, engineAddr); 
    }

    function engineOf(bytes32 name) public view returns (address) {
        return _engines[name];
    }

    function engineOfString(string calldata name) external view returns (address) {
        bytes32 k = _toBytes32(name);
        return engineOf(k);
    }

    function setToken(address newToken) external onlyOwner {
        address prev = token;
        token = newToken;
        emit TokenUpdated(prev, newToken, msg.sender);
    }

    function setManifest(string calldata newManifest) external onlyOwner {
        string memory prev = manifest;
        manifest = newManifest;
        emit ManifestUpdated(prev, newManifest, msg.sender);
    }

    function setHint(string calldata newHint) external onlyOwner {
        string memory prev = hint;
        hint = newHint;
        emit HintUpdated(prev, newHint, msg.sender);
    }

    function healthCheck(bytes32[] calldata engineNames)
        external
        view
        returns (address[] memory addrs, address tokenAddr, address ownerAddr, string memory currentManifest, string memory currentHint)
    {
        addrs = new address[](engineNames.length);
        for (uint i = 0; i < engineNames.length; i++) {
            addrs[i] = _engines[engineNames[i]];
        }
        tokenAddr = token;
        ownerAddr = owner;
        currentManifest = manifest;
        currentHint = hint;
    }

    function _toBytes32(string memory source) internal pure returns (bytes32 result) {
        bytes memory temp = bytes(source);
        if (temp.length == 0) {
            return bytes32(0);
        }
        assembly {
            result := mload(add(source, 32))
        }
    }
}