$trumpet

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

interface IERC20Minimal {
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

interface IERC20MetadataMinimal is IERC20Minimal {
    function decimals() external view returns (uint8);
}

library SafeTokenTransfer {
    error TokenTransferFailed();

    function safeTransfer(IERC20Minimal token, address to, uint256 amount) internal {
        _call(token, abi.encodeCall(token.transfer, (to, amount)));
    }

    function safeTransferFrom(IERC20Minimal token, address from, address to, uint256 amount) internal {
        _call(token, abi.encodeCall(token.transferFrom, (from, to, amount)));
    }

    function _call(IERC20Minimal token, bytes memory data) private {
        (bool success, bytes memory result) = address(token).call(data);
        if (!success || (result.length != 0 && !abi.decode(result, (bool)))) {
            revert TokenTransferFailed();
        }
    }
}

contract TrumpetTokenLocker {
    using SafeTokenTransfer for IERC20Minimal;

    error OnlyOwner();
    error InvalidToken();
    error AmountMustBePositive();
    error DurationMustBePositive();
    error ActiveLockExists();
    error NoActiveLock();
    error LockStillActive(uint256 unlockTime);
    error UnsupportedDecimals(uint8 decimals);
    error FeeOnTransferTokensNotSupported();

    struct TokenLock {
        uint256 amount;
        uint256 unlockTime;
    }

    address public immutable owner;
    mapping(address token => TokenLock lock) public locks;

    event TokensLocked(address indexed token, uint256 amount, uint256 unlockTime);
    event LockExtended(address indexed token, uint256 addedAmount, uint256 totalAmount, uint256 unlockTime);
    event TokensWithdrawn(address indexed token, uint256 amount);

    modifier onlyOwner() {
        if (msg.sender != owner) revert OnlyOwner();
        _;
    }

    constructor() {
        owner = msg.sender;
    }

    function lockTokens(address token, uint256 wholeTokenAmount, uint256 durationDays) external onlyOwner {
        _validateToken(token);
        if (wholeTokenAmount == 0) revert AmountMustBePositive();
        if (durationDays == 0) revert DurationMustBePositive();
        if (locks[token].amount != 0) revert ActiveLockExists();

        uint256 amount = _toTokenUnits(token, wholeTokenAmount);
        _pullExactAmount(token, amount);

        uint256 unlockTime = block.timestamp + (durationDays * 1 days);
        locks[token] = TokenLock({amount: amount, unlockTime: unlockTime});

        emit TokensLocked(token, amount, unlockTime);
    }

    function relockTokens(address token, uint256 additionalWholeTokens, uint256 additionalDays) external onlyOwner {
        TokenLock storage currentLock = locks[token];
        if (currentLock.amount == 0) revert NoActiveLock();
        if (additionalDays == 0) revert DurationMustBePositive();

        uint256 addedAmount;
        if (additionalWholeTokens != 0) {
            addedAmount = _toTokenUnits(token, additionalWholeTokens);
            _pullExactAmount(token, addedAmount);
            currentLock.amount += addedAmount;
        }

        uint256 extensionStart = currentLock.unlockTime > block.timestamp
            ? currentLock.unlockTime
            : block.timestamp;
        currentLock.unlockTime = extensionStart + (additionalDays * 1 days);

        emit LockExtended(token, addedAmount, currentLock.amount, currentLock.unlockTime);
    }

    function withdrawTokens(address token) external onlyOwner {
        TokenLock memory currentLock = locks[token];
        if (currentLock.amount == 0) revert NoActiveLock();
        if (block.timestamp < currentLock.unlockTime) {
            revert LockStillActive(currentLock.unlockTime);
        }

        delete locks[token];
        IERC20Minimal(token).safeTransfer(owner, currentLock.amount);

        emit TokensWithdrawn(token, currentLock.amount);
    }

    function _validateToken(address token) private view {
        if (token == address(0) || token.code.length == 0) revert InvalidToken();
    }

    function _toTokenUnits(address token, uint256 wholeTokenAmount) private view returns (uint256) {
        uint8 tokenDecimals = IERC20MetadataMinimal(token).decimals();
        if (tokenDecimals > 77) revert UnsupportedDecimals(tokenDecimals);
        return wholeTokenAmount * (10 ** uint256(tokenDecimals));
    }

    function _pullExactAmount(address token, uint256 amount) private {
        IERC20Minimal erc20 = IERC20Minimal(token);
        uint256 balanceBefore = erc20.balanceOf(address(this));
        erc20.safeTransferFrom(owner, address(this), amount);
        uint256 received = erc20.balanceOf(address(this)) - balanceBefore;
        if (received != amount) revert FeeOnTransferTokensNotSupported();
    }
}