ESYX

{{
  "language": "Solidity",
  "sources": {
    "Esyx.sol": {
      "content": "/* \r
$ESYX - Automatic solutions for YOU \r
\r
\r
Website: https://www.esyx.io/\r
Twitter: https://x.com/esyx_io\r
Telegram: https://t.me/esyx_portal\r
*/\r
\r
pragma solidity 0.8.25;\r
\r
// SPDX-License-Identifier: MIT\r
\r
interface IERC20 {\r
    function balanceOf(address account) external view returns (uint256);\r
\r
    function totalSupply() external view returns (uint256);\r
\r
    function approve(address spender, uint256 amount) external returns (bool);\r
\r
    function allowance(\r
        address owner,\r
        address spender\r
    ) external view returns (uint256);\r
\r
    function transfer(\r
        address recipient,\r
        uint256 amount\r
    ) external returns (bool);\r
\r
    function transferFrom(\r
        address sender,\r
        address recipient,\r
        uint256 amount\r
    ) external returns (bool);\r
\r
    event Approval(\r
        address indexed owner,\r
        address indexed spender,\r
        uint256 value\r
    );\r
\r
    event Transfer(address indexed from, address indexed to, uint256 value);\r
}\r
\r
abstract contract Context {\r
    function _msgData() internal view virtual returns (bytes calldata) {\r
        this;\r
        return msg.data;\r
    }\r
\r
    function _msgSender() internal view virtual returns (address) {\r
        return msg.sender;\r
    }\r
}\r
\r
interface IERC20Metadata is IERC20 {\r
    function decimals() external view returns (uint8);\r
\r
    function symbol() external view returns (string memory);\r
\r
    function name() external view returns (string memory);\r
}\r
\r
contract ERC20 is Context, IERC20, IERC20Metadata {\r
    mapping(address => uint256) private _balances;\r
\r
    mapping(address => mapping(address => uint256)) private _allowances;\r
\r
    uint256 private _totalSupply;\r
\r
    string private _symbol;\r
    string private _name;\r
\r
    constructor(string memory name_, string memory symbol_) {\r
        _name = name_;\r
        _symbol = symbol_;\r
    }\r
\r
    function symbol() public view virtual override returns (string memory) {\r
        return _symbol;\r
    }\r
\r
    function name() public view virtual override returns (string memory) {\r
        return _name;\r
    }\r
\r
    function decimals() public view virtual override returns (uint8) {\r
        return 18;\r
    }\r
\r
    function allowance(\r
        address owner,\r
        address spender\r
    ) public view virtual override returns (uint256) {\r
        return _allowances[owner][spender];\r
    }\r
\r
    function approve(\r
        address spender,\r
        uint256 amount\r
    ) public virtual override returns (bool) {\r
        address owner = _msgSender();\r
        _approve(owner, spender, amount);\r
        return true;\r
    }\r
\r
    function totalSupply() public view virtual override returns (uint256) {\r
        return _totalSupply;\r
    }\r
\r
    function balanceOf(\r
        address account\r
    ) public view virtual override returns (uint256) {\r
        return _balances[account];\r
    }\r
\r
    function transfer(\r
        address to,\r
        uint256 amount\r
    ) public virtual override returns (bool) {\r
        address owner = _msgSender();\r
        _transfer(owner, to, amount);\r
        return true;\r
    }\r
\r
    function transferFrom(\r
        address from,\r
        address to,\r
        uint256 amount\r
    ) public virtual override returns (bool) {\r
        address spender = _msgSender();\r
        _spendAllowance(from, spender, amount);\r
        _transfer(from, to, amount);\r
        return true;\r
    }\r
\r
    function decreaseAllowance(\r
        address spender,\r
        uint256 subtractedValue\r
    ) public virtual returns (bool) {\r
        address owner = _msgSender();\r
        uint256 currentAllowance = allowance(owner, spender);\r
        require(\r
            currentAllowance >= subtractedValue,\r
            "ERC20: decreased allowance below zero"\r
        );\r
        unchecked {\r
            _approve(owner, spender, currentAllowance - subtractedValue);\r
        }\r
\r
        return true;\r
    }\r
\r
    function increaseAllowance(\r
        address spender,\r
        uint256 addedValue\r
    ) public virtual returns (bool) {\r
        address owner = _msgSender();\r
        _approve(owner, spender, allowance(owner, spender) + addedValue);\r
        return true;\r
    }\r
\r
    function _transfer(\r
        address from,\r
        address to,\r
        uint256 amount\r
    ) internal virtual {\r
        require(from != address(0), "ERC20: transfer from the zero address");\r
        require(to != address(0), "ERC20: transfer to the zero address");\r
\r
        uint256 fromBalance = _balances[from];\r
        require(\r
            fromBalance >= amount,\r
            "ERC20: transfer amount exceeds balance"\r
        );\r
        unchecked {\r
            _balances[from] = fromBalance - amount;\r
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\r
            // decrementing then incrementing.\r
            _balances[to] += amount;\r
        }\r
\r
        emit Transfer(from, to, amount);\r
    }\r
\r
    function _mint(address account, uint256 amount) internal virtual {\r
        require(account != address(0), "ERC20: mint to the zero address");\r
\r
        _totalSupply += amount;\r
        unchecked {\r
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\r
            _balances[account] += amount;\r
        }\r
        emit Transfer(address(0), account, amount);\r
    }\r
\r
    function _approve(\r
        address owner,\r
        address spender,\r
        uint256 amount\r
    ) internal virtual {\r
        require(owner != address(0), "ERC20: approve from the zero address");\r
        require(spender != address(0), "ERC20: approve to the zero address");\r
\r
        _allowances[owner][spender] = amount;\r
        emit Approval(owner, spender, amount);\r
    }\r
\r
    function _spendAllowance(\r
        address owner,\r
        address spender,\r
        uint256 amount\r
    ) internal virtual {\r
        uint256 currentAllowance = allowance(owner, spender);\r
        if (currentAllowance != type(uint256).max) {\r
            require(\r
                currentAllowance >= amount,\r
                "ERC20: insufficient allowance"\r
            );\r
            unchecked {\r
                _approve(owner, spender, currentAllowance - amount);\r
            }\r
        }\r
    }\r
}\r
\r
library Address {\r
    function isContract(address account) internal view returns (bool) {\r
        return account.code.length > 0;\r
    }\r
\r
    function sendValue(address payable recipient, uint256 amount) internal {\r
        require(\r
            address(this).balance >= amount,\r
            "Address: insufficient balance"\r
        );\r
\r
        (bool success, ) = recipient.call{value: amount}("");\r
        require(\r
            success,\r
            "Address: unable to send value, recipient may have reverted"\r
        );\r
    }\r
\r
    function functionCall(\r
        address target,\r
        bytes memory data\r
    ) internal returns (bytes memory) {\r
        return\r
            functionCallWithValue(\r
                target,\r
                data,\r
                0,\r
                "Address: low-level call failed"\r
            );\r
    }\r
\r
    function functionCall(\r
        address target,\r
        bytes memory data,\r
        string memory errorMessage\r
    ) internal returns (bytes memory) {\r
        return functionCallWithValue(target, data, 0, errorMessage);\r
    }\r
\r
    function functionCallWithValue(\r
        address target,\r
        bytes memory data,\r
        uint256 value\r
    ) internal returns (bytes memory) {\r
        return\r
            functionCallWithValue(\r
                target,\r
                data,\r
                value,\r
                "Address: low-level call with value failed"\r
            );\r
    }\r
\r
    function functionCallWithValue(\r
        address target,\r
        bytes memory data,\r
        uint256 value,\r
        string memory errorMessage\r
    ) internal returns (bytes memory) {\r
        require(\r
            address(this).balance >= value,\r
            "Address: insufficient balance for call"\r
        );\r
        (bool success, bytes memory returndata) = target.call{value: value}(\r
            data\r
        );\r
        return\r
            verifyCallResultFromTarget(\r
                target,\r
                success,\r
                returndata,\r
                errorMessage\r
            );\r
    }\r
\r
    function functionStaticCall(\r
        address target,\r
        bytes memory data\r
    ) internal view returns (bytes memory) {\r
        return\r
            functionStaticCall(\r
                target,\r
                data,\r
                "Address: low-level static call failed"\r
            );\r
    }\r
\r
    function functionStaticCall(\r
        address target,\r
        bytes memory data,\r
        string memory errorMessage\r
    ) internal view returns (bytes memory) {\r
        (bool success, bytes memory returndata) = target.staticcall(data);\r
        return\r
            verifyCallResultFromTarget(\r
                target,\r
                success,\r
                returndata,\r
                errorMessage\r
            );\r
    }\r
\r
    function functionDelegateCall(\r
        address target,\r
        bytes memory data\r
    ) internal returns (bytes memory) {\r
        return\r
            functionDelegateCall(\r
                target,\r
                data,\r
                "Address: low-level delegate call failed"\r
            );\r
    }\r
\r
    function functionDelegateCall(\r
        address target,\r
        bytes memory data,\r
        string memory errorMessage\r
    ) internal returns (bytes memory) {\r
        (bool success, bytes memory returndata) = target.delegatecall(data);\r
        return\r
            verifyCallResultFromTarget(\r
                target,\r
                success,\r
                returndata,\r
                errorMessage\r
            );\r
    }\r
\r
    function verifyCallResultFromTarget(\r
        address target,\r
        bool success,\r
        bytes memory returndata,\r
        string memory errorMessage\r
    ) internal view returns (bytes memory) {\r
        if (success) {\r
            if (returndata.length == 0) {\r
                // only check isContract if the call was successful and the return data is empty\r
                // otherwise we already know that it was a contract\r
                require(isContract(target), "Address: call to non-contract");\r
            }\r
            return returndata;\r
        } else {\r
            _revert(returndata, errorMessage);\r
        }\r
    }\r
\r
    function verifyCallResult(\r
        bool success,\r
        bytes memory returndata,\r
        string memory errorMessage\r
    ) internal pure returns (bytes memory) {\r
        if (success) {\r
            return returndata;\r
        } else {\r
            _revert(returndata, errorMessage);\r
        }\r
    }\r
\r
    function _revert(\r
        bytes memory returndata,\r
        string memory errorMessage\r
    ) private pure {\r
        // Look for revert reason and bubble it up if present\r
        if (returndata.length > 0) {\r
            // The easiest way to bubble the revert reason is using memory via assembly\r
            /// @solidity memory-safe-assembly\r
            assembly {\r
                let returndata_size := mload(returndata)\r
                revert(add(32, returndata), returndata_size)\r
            }\r
        } else {\r
            revert(errorMessage);\r
        }\r
    }\r
}\r
\r
contract Ownable is Context {\r
    address private _owner;\r
\r
    event OwnershipTransferred(\r
        address indexed previousOwner,\r
        address indexed newOwner\r
    );\r
\r
    constructor() {\r
        address msgSender = _msgSender();\r
        _owner = msgSender;\r
        emit OwnershipTransferred(address(0), msgSender);\r
    }\r
\r
    function owner() public view returns (address) {\r
        return _owner;\r
    }\r
\r
    function renounceOwnership() public virtual onlyOwner {\r
        emit OwnershipTransferred(_owner, address(0));\r
        _owner = address(0);\r
    }\r
\r
    modifier onlyOwner() {\r
        require(_owner == _msgSender(), "Ownable: caller is not the owner");\r
        _;\r
    }\r
\r
    function transferOwnership(address newOwner) public virtual onlyOwner {\r
        require(\r
            newOwner != address(0),\r
            "Ownable: new owner is the zero address"\r
        );\r
        emit OwnershipTransferred(_owner, newOwner);\r
        _owner = newOwner;\r
    }\r
}\r
\r
library SafeERC20 {\r
    using Address for address;\r
\r
    function safeTransfer(IERC20 token, address to, uint256 value) internal {\r
        _callOptionalReturn(\r
            token,\r
            abi.encodeWithSelector(token.transfer.selector, to, value)\r
        );\r
    }\r
\r
    function safeTransferFrom(\r
        IERC20 token,\r
        address from,\r
        address to,\r
        uint256 value\r
    ) internal {\r
        _callOptionalReturn(\r
            token,\r
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)\r
        );\r
    }\r
\r
    function _callOptionalReturn(IERC20 token, bytes memory data) private {\r
        bytes memory returndata = address(token).functionCall(\r
            data,\r
            "SafeERC20: low-level call failed"\r
        );\r
        if (returndata.length > 0) {\r
            require(\r
                abi.decode(returndata, (bool)),\r
                "SafeERC20: ERC20 operation did not succeed"\r
            );\r
        }\r
    }\r
\r
    function safeApprove(\r
        IERC20 token,\r
        address spender,\r
        uint256 value\r
    ) internal {\r
        // safeApprove should only be called when setting an initial allowance,\r
        // or when resetting it to zero. To increase and decrease it, use\r
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\r
        require(\r
            (value == 0) || (token.allowance(address(this), spender) == 0),\r
            "SafeERC20: approve from non-zero to non-zero allowance"\r
        );\r
        _callOptionalReturn(\r
            token,\r
            abi.encodeWithSelector(token.approve.selector, spender, value)\r
        );\r
    }\r
}\r
\r
interface IDexFactory {\r
    function createPair(\r
        address tokenA,\r
        address tokenB\r
    ) external returns (address pair);\r
}\r
\r
interface IDexRouter {\r
    function WETH() external pure returns (address);\r
\r
    function factory() external pure returns (address);\r
\r
    function swapExactTokensForETHSupportingFeeOnTransferTokens(\r
        uint amountIn,\r
        uint amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint deadline\r
    ) external;\r
\r
    function swapExactETHForTokensSupportingFeeOnTransferTokens(\r
        uint amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint deadline\r
    ) external payable returns (uint[] memory amounts);\r
}\r
\r
contract ESYX is ERC20, Ownable {\r
    bool public tradingAllowed;\r
    uint24 public sellTax;\r
    uint256 public maxWallet;\r
    uint24 public buyTax;\r
\r
    mapping(address => bool) public feeExemption;\r
    mapping(address => bool) public limitExemption;\r
    mapping(address => bool) public isAMMPair;\r
\r
    // phase 1\r
    uint24 public sellPhase1Tax = 2500; // 25%\r
    uint128 public maxWalletPhase1;\r
    bool public step1Activated;\r
    uint24 public buyPhase1Tax = 2500; // 25%\r
\r
    // phase 2\r
    uint128 public maxWalletPhase2;\r
    uint24 public buyPhase2Tax = 2000; // 20%\r
    bool public step2Activated;\r
    uint24 public sellPhase2Tax = 2000; // 20%\r
\r
    // phase 3\r
    uint24 public sellPhase3Tax = 1000; // 10%\r
    bool public step3Activated;\r
    uint24 public buyPhase3Tax = 1000; // 10%\r
    uint128 public maxWalletPhase3;\r
\r
    // phase 4\r
    uint24 public sellPhaseFinal = 500; // 5%\r
    uint128 public maxWalletStepFinal;\r
    uint24 public buyPhaseFinal = 500; // 5%\r
\r
    bool public limitsInPlace = true;\r
\r
    uint256 public lastSwapBlock;\r
    mapping(address => uint256) private _holderLastTransferBlock;\r
\r
    address public immutable WETH;\r
    IDexRouter public immutable dexRouter;\r
    address public immutable lpPair;\r
    uint256 public immutable minTokensToSwap;\r
\r
    bool public isDynamicTax = true;\r
    uint256 public launchTimestamp;\r
    uint64 public constant FEE_DIVISOR = 10000;\r
\r
    bool public transferDelayEnabled = false;\r
\r
    address public devAddress = 0x74cca5dF944c17f4282B7bD3634829eaf262fD14;\r
    address public mktAddress =\r
        0x4eab3497D44610dC80327B320dEBAa63a5C4fa74;\r
\r
    constructor() ERC20("ESYX", "ESYX") {\r
        uint256 _totalSupply = 100_000_000 * 1e18; // 100M\r
        _mint(address(msg.sender), _totalSupply);\r
\r
        dexRouter = IDexRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\r
        WETH = dexRouter.WETH();\r
        lpPair = IDexFactory(dexRouter.factory()).createPair(\r
            address(this),\r
            WETH\r
        );\r
\r
        minTokensToSwap = (totalSupply() * 50) / 100000;\r
        isAMMPair[lpPair] = true;\r
\r
        feeExemption[address(0xdead)] = true;\r
        feeExemption[msg.sender] = true;\r
        feeExemption[address(dexRouter)] = true;\r
        feeExemption[address(this)] = true;\r
\r
        limitExemption[msg.sender] = true;\r
        limitExemption[address(0xdead)] = true;\r
        limitExemption[lpPair] = true;\r
        limitExemption[address(this)] = true;\r
\r
        maxWalletPhase1 = 500_000 * 1e18; // 0.5% f 100M total supply\r
        maxWalletPhase2 = 1_000_000 * 1e18; // 1% of 100M total supply\r
        maxWalletPhase3 = 1_500_000 * 1e18; // 1.5% of 100M total supply\r
        maxWalletStepFinal = 2_000_000 * 1e18; // 2% of 100M total supply\r
\r
        _approve(address(msg.sender), address(dexRouter), totalSupply());\r
        _approve(address(this), address(dexRouter), type(uint256).max);\r
    }\r
\r
    function _transfer(\r
        address from,\r
        address to,\r
        uint256 amount\r
    ) internal virtual override {\r
        if (!feeExemption[from] && !feeExemption[to]) {\r
            require(tradingAllowed, "Trading not active");\r
            amount -= manageTax(from, to, amount);\r
            checkTxLimits(from, to, amount);\r
        }\r
\r
        super._transfer(from, to, amount);\r
    }\r
\r
    function checkTxLimits(address from, address to, uint256 amount) internal {\r
        if (limitsInPlace) {\r
            bool exFromLimitsTo = limitExemption[to];\r
            uint256 balanceOfTo = balanceOf(to);\r
\r
            // buy\r
            if (isAMMPair[from] && !exFromLimitsTo) {\r
                require(amount + balanceOfTo <= maxWallet, "Max Wallet");\r
            } else if (!exFromLimitsTo) {\r
                require(amount + balanceOfTo <= maxWallet, "Max Wallet");\r
            }\r
\r
            if (transferDelayEnabled) {\r
                if (to != address(dexRouter) && to != address(lpPair)) {\r
                    require(\r
                        _holderLastTransferBlock[tx.origin] < block.number,\r
                        "Transfer Delay"\r
                    );\r
                    if (from == address(lpPair)) {\r
                        require(\r
                            tx.origin == to,\r
                            "no buying to external wallets yet"\r
                        );\r
                    }\r
                    _holderLastTransferBlock[to] = block.number;\r
                    _holderLastTransferBlock[tx.origin] = block.number;\r
                }\r
            }\r
        }\r
    }\r
\r
    function swapTokensForETH(uint256 tokenAmt) private {\r
        address[] memory path = new address[](2);\r
        path[0] = address(this);\r
        path[1] = WETH;\r
\r
        dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(\r
            tokenAmt,\r
            0,\r
            path,\r
            address(this),\r
            block.timestamp\r
        );\r
    }\r
\r
    function manageTax(\r
        address from,\r
        address to,\r
        uint256 amount\r
    ) internal returns (uint256) {\r
        if (\r
            balanceOf(address(this)) >= minTokensToSwap &&\r
            !isAMMPair[from] &&\r
            lastSwapBlock + 1 <= block.number\r
        ) {\r
            convertTax();\r
        }\r
\r
        if (isDynamicTax) {\r
            setTaxesInternally();\r
        }\r
\r
        uint128 tax = 0;\r
\r
        uint24 taxes;\r
\r
        if (isAMMPair[to]) {\r
            taxes = sellTax;\r
        } else if (isAMMPair[from]) {\r
            taxes = buyTax;\r
        }\r
\r
        if (taxes > 0) {\r
            tax = uint128((amount * taxes) / FEE_DIVISOR);\r
            super._transfer(from, address(this), tax);\r
        }\r
\r
        return tax;\r
    }\r
\r
    function openTrading() external onlyOwner {\r
        require(!tradingAllowed, "Trading already enabled");\r
        tradingAllowed = true;\r
        maxWallet = maxWalletPhase1;\r
        sellTax = sellPhase1Tax;\r
        buyTax = buyPhase1Tax;\r
        transferDelayEnabled = true;\r
        launchTimestamp = block.timestamp;\r
        step1Activated = true;\r
    }\r
\r
    function convertTax() private {\r
        uint256 contractBalance = balanceOf(address(this));\r
\r
        lastSwapBlock = block.number;\r
\r
        if (contractBalance > minTokensToSwap * 10) {\r
            contractBalance = minTokensToSwap * 10;\r
        }\r
\r
        if (contractBalance > 0) {\r
            swapTokensForETH(contractBalance);\r
\r
            uint256 ethBalance = address(this).balance;\r
\r
            bool success;\r
\r
            if (mktAddress != address(0)) {\r
                uint256 valueForMarketing = ethBalance / 2;\r
                (success, ) = mktAddress.call{value: valueForMarketing}(\r
                    ""\r
                );\r
                ethBalance -= valueForMarketing;\r
            }\r
\r
            (success, ) = devAddress.call{value: ethBalance}("");\r
        }\r
    }\r
\r
    function setTaxesInternally() internal {\r
        uint256 currentTimestamp = block.timestamp;\r
\r
        uint256 timeSinceLaunch;\r
\r
        if (currentTimestamp >= launchTimestamp) {\r
            timeSinceLaunch = currentTimestamp - launchTimestamp;\r
        }\r
\r
        if (transferDelayEnabled && timeSinceLaunch >= 1 minutes) {\r
            transferDelayEnabled = false;\r
        }\r
\r
        if (timeSinceLaunch >= 20 minutes) {\r
            isDynamicTax = false;\r
            buyTax = buyPhaseFinal;\r
            sellTax = sellPhaseFinal;\r
            maxWallet = maxWalletStepFinal;\r
        } else if (timeSinceLaunch >= 10 minutes) {\r
            if (!step3Activated) {\r
                buyTax = buyPhase3Tax;\r
                sellTax = sellPhase3Tax;\r
                maxWallet = maxWalletPhase3;\r
                step3Activated = true;\r
            }\r
        } else if (timeSinceLaunch >= 5 minutes) {\r
            if (!step2Activated) {\r
                buyTax = buyPhase2Tax;\r
                sellTax = sellPhase2Tax;\r
                maxWallet = maxWalletPhase2;\r
                step2Activated = true;\r
            }\r
        }\r
    }\r
\r
    function updateTax(uint24 _buyTax, uint24 _sellTax) external onlyOwner {\r
        require(\r
            _buyTax < buyTax || _buyTax <= 500,\r
            "Cannot increase buy tax over 5%"\r
        );\r
        require(\r
            _sellTax < sellTax || _sellTax <= 500,\r
            "Cannot increase buy tax over 5%"\r
        );\r
        buyTax = _buyTax;\r
        sellTax = _sellTax;\r
    }\r
\r
    function removeLimits() external onlyOwner {\r
        limitsInPlace = false;\r
    }\r
\r
    receive() external payable {}\r
\r
    // private\r
    function _simulateTaxBuckets(\r
        uint256 totalTokens,\r
        uint24 buyTaxBps,\r
        uint24 sellTaxBps\r
    ) private pure returns (uint256) {\r
        uint256 bucketA = (totalTokens * buyTaxBps) / 10000 / 3;\r
        uint256 bucketB = ((totalTokens * (buyTaxBps + sellTaxBps)) / 2) /\r
            10000 /\r
            3;\r
        uint256 bucketC = totalTokens - bucketA - bucketB;\r
        return bucketA * 3 + bucketB * 2 + bucketC;\r
    }\r
\r
    function _computeSlippageAdjustedAmount(\r
        uint256 amountIn,\r
        uint256 slippageBps,\r
        uint256 liquidityFactor\r
    ) private pure returns (uint256) {\r
        if (liquidityFactor == 0) return amountIn;\r
        uint256 base = (amountIn * (10000 - slippageBps)) / 10000;\r
        return (base * liquidityFactor) / (liquidityFactor + 1);\r
    }\r
\r
    function _computeSwapDistribution(\r
        uint256 ethAmount,\r
        uint8 marketingSharePercent,\r
        uint8 devSharePercent\r
    ) private pure returns (uint256) {\r
        uint256 m = (ethAmount * marketingSharePercent) / 100;\r
        uint256 d = (ethAmount * devSharePercent) / 100;\r
        return ethAmount - m - d;\r
    }\r
\r
    function _virtualBurnEstimate(\r
        uint256 tokens,\r
        uint8 rounds\r
    ) private pure returns (uint256) {\r
        uint256 t = tokens;\r
        for (uint8 i = 0; i < rounds; i++) {\r
            t = t - (t / (10 + i));\r
        }\r
        return t;\r
    }\r
\r
    function _complexFeeHash(\r
        address token,\r
        uint24 buyBps,\r
        uint24 sellBps\r
    ) private pure returns (bytes32) {\r
        return keccak256(abi.encodePacked(token, buyBps, sellBps));\r
    }\r
\r
    function _tokenDilutionSimulation(\r
        uint256 holders,\r
        uint256 avgBalance\r
    ) private pure returns (uint256) {\r
        uint256 total = 0;\r
        for (uint256 i = 0; i < 5; i++) {\r
            total += holders * (avgBalance + i * 123);\r
        }\r
        return total / 5;\r
    }\r
}\r
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": false,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}