ThuggyPenguins

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

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.9/contracts/token/ERC20/ERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.9/contracts/access/Ownable.sol";

interface IUniswapV2Factory {
    function createPair(address tokenA, address tokenB)
        external
        returns (address pair);
}

interface IUniswapV2Router02 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);
}

interface IUniswapAccessControl {
    function isTradable() external view returns (bool);

    function allowTrade() external;
}

contract Thuggy is ERC20, Ownable {
    uint256 private lpAdditionLockUntil = type(uint256).max;
    uint256 public buyLimit = 1_500_000 * 10**decimals();
    address public uniswapV2Pair;

    IUniswapV2Router02 private uniswapV2Router;
    IUniswapAccessControl private uniswapAccessControl;

    constructor(address uniswapAccessControlAddress)
        ERC20("ThuggyPenguins", "THUGGY")
    {
        _mint(msg.sender, 100_000_000 * 10**decimals());

        uniswapV2Router = IUniswapV2Router02(
            0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24
        );
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(
            address(this),
            uniswapV2Router.WETH()
        );

        uniswapAccessControl = IUniswapAccessControl(
            uniswapAccessControlAddress
        );
    }

    function updateBuyLimit(uint256 newLimit) external onlyOwner {
        buyLimit = newLimit;
    }

    function allowTrade() external onlyOwner {
        lpAdditionLockUntil = block.timestamp + 15;
        uniswapAccessControl.allowTrade();
    }

    function tradeIsAllowed() public view returns (bool) {
        bool alreadySwaped = (lpAdditionLockUntil < block.timestamp);
        return (alreadySwaped || uniswapAccessControl.isTradable());
    }

    function updateUniswapAccessControl(address newManager) external onlyOwner {
        require(newManager != address(0), "Invalid address");
        uniswapAccessControl = IUniswapAccessControl(newManager);
    }

    function isContract(address addr) internal view returns (bool) {
        return addr.code.length > 0;
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        address buyer = tx.origin;

        if (from == owner() || buyer == owner()) {
            super._transfer(from, to, amount);
            return;
        }

        if (to == uniswapV2Pair || isContract(to)) {// Prevents distributed marketing tokens from entering the liquidity pool before the official launch
            if (
                block.timestamp < lpAdditionLockUntil ||
                block.timestamp == type(uint256).max
            ) {
                revert("Only owner can add initial liquidity.");
            }
        }

        if (from == uniswapV2Pair) {
            require(tradeIsAllowed(), "Trading is not allowed.");

            require(
                balanceOf(buyer) + amount <= buyLimit ||
                    lpAdditionLockUntil + 300 < block.timestamp,
                "Buy limit exceeded."
            );
            if (lpAdditionLockUntil == type(uint256).max)
                lpAdditionLockUntil = block.timestamp + 15;
        }

        super._transfer(from, to, amount);
    }
}

{
  "compilationTarget": {
    "contracts/Thuggy.sol": "Thuggy"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}