ELEToken

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

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
import {OneTimeConfig} from "./base/OneTimeConfig.sol";

/// @title Self-Backing Stair Token
/// @notice Standard non-rebasing token with an immutable supply ceiling and one-time monetary authorities.
contract ELEToken is ERC20, ERC20Permit, OneTimeConfig {
    error Unauthorized();
    error SupplyCapExceeded();
    error InvalidSupplyConfiguration();

    uint256 public immutable maxSupply;
    address public monetaryController;
    address public reserveVault;

    event MonetaryAuthorityConfigured(address indexed controller, address indexed reserveVault);

    constructor(
        address bootstrapAuthority_,
        address genesisRecipient,
        uint256 genesisSupply,
        uint256 maxSupply_
    )
        ERC20("Self-Backing Staircase", "STAIR")
        ERC20Permit("Self-Backing Staircase")
        OneTimeConfig(bootstrapAuthority_)
    {
        if (genesisRecipient == address(0)) {
            revert ZeroAddress();
        }
        if (genesisSupply == 0 || maxSupply_ < genesisSupply) revert InvalidSupplyConfiguration();
        maxSupply = maxSupply_;
        _mint(genesisRecipient, genesisSupply);
    }

    function configureMonetaryAuthority(address controller, address reserve)
        external
        onlyBootstrap
    {
        if (controller == address(0) || reserve == address(0)) revert ZeroAddress();
        monetaryController = controller;
        reserveVault = reserve;
        _finishConfiguration();
        emit MonetaryAuthorityConfigured(controller, reserve);
    }

    function mint(address to, uint256 amount) external {
        if (msg.sender != monetaryController) revert Unauthorized();
        if (to == address(0)) revert ZeroAddress();
        if (totalSupply() + amount > maxSupply) revert SupplyCapExceeded();
        _mint(to, amount);
    }

    function burnReserve(uint256 amount) external {
        if (msg.sender != reserveVault) revert Unauthorized();
        _burn(msg.sender, amount);
    }
}