Address

• CV.sol

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

/// @title CV (Commitment Value)
/// @notice Uncapped ERC20. No fixed supply. CV is only ever created by the CVProtocol
///         mining contract. The minter is set exactly once by the deployer and then frozen,
///         so after launch there is no admin able to mint or change anything here.
contract CV {
    string public constant name = "Commitment Value";
    string public constant symbol = "CV";
    uint8 public constant decimals = 18;

    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    address public immutable deployer;
    address public minter;
    bool public minterLocked;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event MinterSet(address indexed minter);

    constructor() {
        deployer = msg.sender;
    }

    /// @notice One time wiring. Deployer points CV at the protocol, then it is locked forever.
    function setMinter(address m) external {
        require(msg.sender == deployer, "not deployer");
        require(!minterLocked, "minter locked");
        require(m != address(0), "zero minter");
        minter = m;
        minterLocked = true;
        emit MinterSet(m);
    }

    /// @notice Only the protocol can create CV.
    function mint(address to, uint256 amount) external {
        require(msg.sender == minter, "only minter");
        require(to != address(0), "to zero");
        totalSupply += amount;
        unchecked {
            balanceOf[to] += amount;
        }
        emit Transfer(address(0), to, amount);
    }

    function transfer(address to, uint256 value) external returns (bool) {
        return _transfer(msg.sender, to, value);
    }

    function transferFrom(address from, address to, uint256 value) external returns (bool) {
        uint256 a = allowance[from][msg.sender];
        if (a != type(uint256).max) {
            require(a >= value, "allowance");
            allowance[from][msg.sender] = a - value;
        }
        return _transfer(from, to, value);
    }

    function approve(address spender, uint256 value) external returns (bool) {
        allowance[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    function _transfer(address from, address to, uint256 value) internal returns (bool) {
        require(to != address(0), "to zero");
        uint256 b = balanceOf[from];
        require(b >= value, "balance");
        unchecked {
            balanceOf[from] = b - value;
            balanceOf[to] += value;
        }
        emit Transfer(from, to, value);
        return true;
    }

    /// @notice Burn your own CV. Reduces total supply. Used by the protocol buy and burn.
    function burn(uint256 amount) external {
        uint256 b = balanceOf[msg.sender];
        require(b >= amount, "balance");
        unchecked {
            balanceOf[msg.sender] = b - amount;
        }
        totalSupply -= amount;
        emit Transfer(msg.sender, address(0), amount);
    }
}