Parasol IP Protection

// SPDX-License-Identifier: PROPRIETARY
// Copyright © William Joshua Drown, Dripsy Drown Productions Film & Entertainment™
// Parasol IP Protection — Royalty Token Contract

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

/**
 * @title  ParasolRoyaltyToken (PSOL)
 * @notice ERC-20 royalty entitlement token for Parasol IP Protection.
 *         Only verified holders may receive or hold tokens.
 *         Royalties are scheduled on-chain with a time-lock and released
 *         exclusively by the contract owner (William Joshua Drown).
 */
contract ParasolRoyaltyToken is ERC20, ERC20Burnable, ERC20Permit, Ownable, ReentrancyGuard {

    uint256 public constant MAX_SUPPLY = 100_000_000 * 1e18;

    mapping(address => uint256) public royaltiesReleased;
    mapping(address => bool)    public verifiedHolders;

    struct RoyaltySchedule {
        address recipient;
        uint256 amount;
        uint256 releaseTimestamp;
        bool    released;
        string  projectId;
    }

    RoyaltySchedule[] public schedules;

    event HolderVerified(address indexed holder, bool status);
    event RoyaltyScheduled(uint256 indexed scheduleId, address indexed recipient, uint256 amount, string projectId);
    event RoyaltyReleased(uint256 indexed scheduleId, address indexed recipient, uint256 amount);

    constructor(address initialOwner)
        ERC20("Parasol Royalty Token", "PSOL")
        ERC20Permit("Parasol Royalty Token")
        Ownable(initialOwner)
    {}

    function mint(address to, uint256 amount) external onlyOwner {
        require(verifiedHolders[to], "ParasolRoyalty: recipient not verified");
        require(totalSupply() + amount <= MAX_SUPPLY, "ParasolRoyalty: exceeds max supply");
        _mint(to, amount);
    }

    function setVerifiedHolder(address holder, bool status) external onlyOwner {
        verifiedHolders[holder] = status;
        emit HolderVerified(holder, status);
    }

    function scheduleRoyalty(
        address recipient, uint256 amount, uint256 releaseTimestamp, string calldata projectId
    ) external onlyOwner returns (uint256 scheduleId) {
        require(verifiedHolders[recipient], "ParasolRoyalty: recipient not verified");
        require(releaseTimestamp >= block.timestamp, "ParasolRoyalty: release time in the past");
        require(totalSupply() + amount <= MAX_SUPPLY, "ParasolRoyalty: would exceed max supply");
        scheduleId = schedules.length;
        schedules.push(RoyaltySchedule(recipient, amount, releaseTimestamp, false, projectId));
        emit RoyaltyScheduled(scheduleId, recipient, amount, projectId);
    }

    function releaseRoyalty(uint256 scheduleId) external onlyOwner nonReentrant {
        RoyaltySchedule storage s = schedules[scheduleId];
        require(!s.released, "ParasolRoyalty: already released");
        require(block.timestamp >= s.releaseTimestamp, "ParasolRoyalty: not yet due");
        require(totalSupply() + s.amount <= MAX_SUPPLY, "ParasolRoyalty: exceeds max supply");
        s.released = true;
        royaltiesReleased[s.recipient] += s.amount;
        _mint(s.recipient, s.amount);
        emit RoyaltyReleased(scheduleId, s.recipient, s.amount);
    }

    function scheduleCount() external view returns (uint256) {
        return schedules.length;
    }

    // Soulbound transfer guard
    function _update(address from, address to, uint256 value) internal override {
        if (from != address(0) && to != address(0)) {
            require(verifiedHolders[to] || to == owner(), "ParasolRoyalty: recipient not verified");
        }
        super._update(from, to, value);
    }
}