Contracts that hold up on mainnet

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

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
import {VestingWallet} from "@openzeppelin/contracts/finance/VestingWallet.sol";

contract BlockStartumToken is ERC20, ERC20Permit, Ownable2Step {
    uint256 public constant MAX_TEAM_BPS = 2_000; // team allocation capped at 20%

    VestingWallet public immutable teamVesting;
    uint256 public immutable maxTxAmount; // 1% of supply, launch anti-bot only
    bool public limitsActive = true;
    string private _contractURI;

    error TeamShareTooHigh();
    error ZeroTeamWallet();
    error MaxTxExceeded(uint256 value, uint256 max);

    event LimitsRemoved();
    event ContractURIUpdated(); // ERC-7572

    /// @param totalSupply_     whole tokens, e.g. 1000000000 for 1B
    /// @param owner_           Safe multisig that receives the non-team supply
    /// @param teamBps_         team share in basis points (1000 = 10%), max 2000
    /// @param cliffSeconds_    nothing unlocks before this (31536000 = 12 months)
    /// @param vestingSeconds_  linear unlock after the cliff (0 = everything at the cliff)
    /// @param contractURI_     e.g. ipfs://.../token.json with name, image, website, socials
    constructor(
        string memory name_,
        string memory symbol_,
        uint256 totalSupply_,
        address owner_,
        address teamWallet_,
        uint256 teamBps_,
        uint64 cliffSeconds_,
        uint64 vestingSeconds_,
        string memory contractURI_
    ) ERC20(name_, symbol_) ERC20Permit(name_) Ownable(owner_) {
        if (teamBps_ > MAX_TEAM_BPS) revert TeamShareTooHigh();

        uint256 supply = totalSupply_ * 10 ** decimals();
        uint256 teamAmount = (supply * teamBps_) / 10_000;
        maxTxAmount = supply / 100;
        _contractURI = contractURI_;

        if (teamAmount > 0) {
            if (teamWallet_ == address(0)) revert ZeroTeamWallet();
            teamVesting = new VestingWallet(
                teamWallet_,
                uint64(block.timestamp) + cliffSeconds_,
                vestingSeconds_
            );
            _mint(address(teamVesting), teamAmount);
        }
        _mint(owner_, supply - teamAmount);
        // No mint function exists after this point: total supply is fixed forever.
    }

    /// One-way switch. Limits can be removed, never turned back on or tightened.
    function removeLimits() external onlyOwner {
        limitsActive = false;
        emit LimitsRemoved();
    }

    function contractURI() external view returns (string memory) {
        return _contractURI;
    }

    function setContractURI(string calldata newURI) external onlyOwner {
        _contractURI = newURI;
        emit ContractURIUpdated();
    }

    function _update(address from, address to, uint256 value) internal override {
        if (
            limitsActive &&
            from != address(0) && to != address(0) &&       // mint / burn
            from != owner() && to != owner() &&             // liquidity from the Safe
            from != address(teamVesting)                    // vesting releases
        ) {
            if (value > maxTxAmount) revert MaxTxExceeded(value, maxTxAmount);
        }
        super._update(from, to, value);
    }
}

/// Holds LP tokens until unlockTime. The lock can be extended, never shortened.
contract LiquidityLock {
    using SafeERC20 for IERC20;

    IERC20 public immutable lpToken;
    address public immutable beneficiary;
    uint64 public unlockTime;

    error NotBeneficiary();
    error InvalidUnlockTime();
    error StillLocked(uint64 unlockTime);
    error NothingLocked();

    event LockExtended(uint64 newUnlockTime);
    event Released(uint256 amount);

    constructor(IERC20 lpToken_, address beneficiary_, uint64 unlockTime_) {
        if (beneficiary_ == address(0)) revert NotBeneficiary();
        if (unlockTime_ <= block.timestamp) revert InvalidUnlockTime();
        lpToken = lpToken_;
        beneficiary = beneficiary_;
        unlockTime = unlockTime_;
    }

    function lockedAmount() external view returns (uint256) {
        return lpToken.balanceOf(address(this));
    }

    function extendLock(uint64 newUnlockTime) external {
        if (msg.sender != beneficiary) revert NotBeneficiary();
        if (newUnlockTime <= unlockTime) revert InvalidUnlockTime();
        unlockTime = newUnlockTime;
        emit LockExtended(newUnlockTime);
    }

    function release() external {
        if (block.timestamp < unlockTime) revert StillLocked(unlockTime);
        uint256 amount = lpToken.balanceOf(address(this));
        if (amount == 0) revert NothingLocked();
        lpToken.safeTransfer(beneficiary, amount);
        emit Released(amount);
    }
}