Address

• contracts/Reflection/PX88.sol

// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;

/*
 * PX88 Reflection Token
 * + Buy/Sell Fees
 * + Anti-Bot Launch Protection
 */

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender,address recipient,uint256 amount) external returns (bool);

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

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

interface IPulseXRouter {
    function factory() external pure returns (address);
    function WPLS() external pure returns (address);
}

contract Ownable is Context {
    address public owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() {
        owner = _msgSender();
        emit OwnershipTransferred(address(0), owner);
    }

    modifier onlyOwner() {
        require(owner == _msgSender(), "Not owner");
        _;
    }

    function renounceOwnership() external onlyOwner {
        emit OwnershipTransferred(owner, address(0));
        owner = address(0);
    }
}

contract PX88 is Context, IERC20, Ownable {

    string private constant _name = "PX88";
    string private constant _symbol = "PX88";
    uint8 private constant _decimals = 18;

    uint256 private constant MAX = type(uint256).max;
    uint256 private constant _tTotal = 1_000_000_088 * 1e18;

    uint256 private _rTotal = (MAX - (MAX % _tTotal));

    mapping(address => uint256) private _rOwned;
    mapping(address => mapping(address => uint256)) private _allowances;
    mapping(address => bool) private _isExcludedFromFee;

    /* PulseX */
    IPulseXRouter public router;
    address public pair;
    address public WPLS;

    /* Fees */
    uint256 public buyReflectionFee = 2;
    uint256 public buyBurnFee = 1;

    uint256 public sellReflectionFee = 3;
    uint256 public sellBurnFee = 2;

    address public constant burnAddress = address(0xdead);

    /* Anti-Bot */
    bool public tradingEnabled;
    uint256 public launchBlock;
    uint256 public antiBotBlocks = 3;
    uint256 public sniperFee = 99; // %

    /* Limits */
    uint256 public maxTxAmount = _tTotal / 100;
    uint256 public maxWalletAmount = _tTotal / 50;
    bool public limitsEnabled = true;

    constructor(address _router) {
        router = IPulseXRouter(_router);
        WPLS = router.WPLS();

        pair = IPulseXFactory(router.factory())
            .createPair(address(this), WPLS);

        _rOwned[_msgSender()] = _rTotal;

        _isExcludedFromFee[_msgSender()] = true;
        _isExcludedFromFee[address(this)] = true;
        _isExcludedFromFee[burnAddress] = true;

        emit Transfer(address(0), _msgSender(), _tTotal);
    }

    /* ERC20 */
    function name() public pure returns (string memory) { return _name; }
    function symbol() public pure returns (string memory) { return _symbol; }
    function decimals() public pure returns (uint8) { return _decimals; }
    function totalSupply() public pure override returns (uint256) { return _tTotal; }

    function balanceOf(address account) public view override returns (uint256) {
        return _rOwned[account] / (_rTotal / _tTotal);
    }

    function allowance(address owner_, address spender) public view override returns (uint256) {
        return _allowances[owner_][spender];
    }

    function approve(address spender, uint256 amount) public override returns (bool) {
        _allowances[_msgSender()][spender] = amount;
        emit Approval(_msgSender(), spender, amount);
        return true;
    }

    function transfer(address recipient, uint256 amount) public override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function transferFrom(address sender,address recipient,uint256 amount) public override returns (bool) {
        _allowances[sender][_msgSender()] -= amount;
        _transfer(sender, recipient, amount);
        return true;
    }

    /* Core Logic */

    function _transfer(address from, address to, uint256 amount) private {
        require(amount > 0, "Zero amount");

        if (!tradingEnabled) {
            require(_isExcludedFromFee[from] || _isExcludedFromFee[to], "Trading off");
        }

        if (limitsEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
            require(amount <= maxTxAmount, "Max TX");
            if (to != pair) {
                require(balanceOf(to) + amount <= maxWalletAmount, "Max wallet");
            }
        }

        bool isBuy = from == pair;
        bool isSell = to == pair;

        uint256 reflectionFee;
        uint256 burnFee;

        /* 👿 Anti-bot window */
        if (
            tradingEnabled &&
            isBuy &&
            block.number <= launchBlock + antiBotBlocks
        ) {
            reflectionFee = sniperFee;
            burnFee = 0;
        } else if (isBuy) {
            reflectionFee = buyReflectionFee;
            burnFee = buyBurnFee;
        } else if (isSell) {
            reflectionFee = sellReflectionFee;
            burnFee = sellBurnFee;
        }

        uint256 rate = _rTotal / _tTotal;

        uint256 tReflection = (amount * reflectionFee) / 100;
        uint256 tBurn = (amount * burnFee) / 100;
        uint256 tTransfer = amount - tReflection - tBurn;

        uint256 rAmount = amount * rate;
        uint256 rTransfer = tTransfer * rate;

        _rOwned[from] -= rAmount;
        _rOwned[to] += rTransfer;

        if (tBurn > 0) {
            _rOwned[burnAddress] += tBurn * rate;
            emit Transfer(from, burnAddress, tBurn);
        }

        _rTotal -= tReflection * rate;

        emit Transfer(from, to, tTransfer);
    }

    /* Admin */

    function enableTrading() external onlyOwner {
        tradingEnabled = true;
        launchBlock = block.number;
    }

    function setAntiBot(uint256 blocks_, uint256 fee_) external onlyOwner {
        antiBotBlocks = blocks_;
        sniperFee = fee_;
    }

    function toggleLimits(bool enabled) external onlyOwner {
        limitsEnabled = enabled;
    }

    function excludeFromFee(address account, bool excluded) external onlyOwner {
        _isExcludedFromFee[account] = excluded;
    }
}