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

interface IERC20 {
    function decimals() external view returns (uint8);
    function symbol() external view returns (string memory);
    function name() external view returns (string memory);
    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 IUniswapV2Router {
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}

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

abstract contract TokenAdmin {
    address internal _admin;
    
    event AdminChanged(address indexed previousAdmin, address indexed newAdmin);
    
    constructor() {
        _admin = msg.sender;
        emit AdminChanged(address(0), msg.sender);
    }
    
    function admin() public view returns (address) {
        return _admin;
    }
    
    modifier onlyAdmin() {
        require(_admin == msg.sender, "Caller is not admin");
        _;
    }
    
    function transferAdmin(address newAdmin) public virtual onlyAdmin {
        require(newAdmin != address(0), "New admin cannot be zero address");
        emit AdminChanged(_admin, newAdmin);
        _admin = newAdmin;
    }
    
    function renounceAdmin() public virtual onlyAdmin {
        emit AdminChanged(_admin, address(0));
        _admin = address(0);
    }
}

contract America250 is IERC20, TokenAdmin {
    // Token metadata
    string private constant TOKEN_NAME = unicode"America250";
    string private constant TOKEN_SYMBOL = "America250";
    uint8 private constant DECIMALS = 18;
    uint256 private constant TOTAL_SUPPLY = 420690000000 * (10**DECIMALS);
    
    // DEX addresses
    address private constant UNISWAP_ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    address private immutable UNISWAP_PAIR;
    
    // Fee addresses
    address private constant INITIAL_HOLDER = 0x691ADDe5bA2F215992755903fE29F0dbF8B3ba38;
    address payable private marketingWallet = payable(0x2fa8198926852041c5c009281c134212b528bdE4);
    
    // Token state
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    mapping(address => bool) private _isExcludedFromFee;
    mapping(address => bool) public isDexPair;
    
    // Fee configuration
    uint256 public buyCounter = 0;
    uint256 private initialBuyFee = 35;
    uint256 private initialSellFee = 35;
    uint256 private finalBuyFee = 35;
    uint256 private finalSellFee = 35;
    uint256 private buyFeeReductionThreshold = 0;
    uint256 private sellFeeReductionThreshold = 0;
    uint256 private feeActivationThreshold = 0;
    
    // Trading controls
    uint256 public tradingStartBlock;
    uint256 public maxWalletBalance = 0;
    uint256 public swapThreshold = TOTAL_SUPPLY / 25000;
    bool public enforceMaxWallet = false;
    bool private inSwapProcess;
    
    // Router instance
    IUniswapV2Router public immutable dexRouter;
    
    modifier swapLock {
        inSwapProcess = true;
        _;
        inSwapProcess = false;
    }
    
    constructor() {
        // Initialize token distribution
        _balances[INITIAL_HOLDER] = TOTAL_SUPPLY;
        emit Transfer(address(0), INITIAL_HOLDER, TOTAL_SUPPLY);
        
        // Set up fee exclusions
        _isExcludedFromFee[address(this)] = true;
        _isExcludedFromFee[INITIAL_HOLDER] = true;
        _isExcludedFromFee[marketingWallet] = true;
        
        // Initialize DEX router
        dexRouter = IUniswapV2Router(UNISWAP_ROUTER);
        _allowances[address(this)][UNISWAP_ROUTER] = type(uint256).max;
        
        // Create DEX pair
        UNISWAP_PAIR = IUniswapV2Factory(dexRouter.factory()).createPair(
            address(this),
            dexRouter.WETH()
        );
        isDexPair[UNISWAP_PAIR] = true;
        
        // Approve WETH
        IERC20(dexRouter.WETH()).approve(UNISWAP_ROUTER, type(uint256).max);
        
        transferAdmin(INITIAL_HOLDER);
    }
    
    // Token standard functions
    function name() external pure override returns (string memory) {
        return TOKEN_NAME;
    }
    
    function symbol() external pure override returns (string memory) {
        return TOKEN_SYMBOL;
    }
    
    function decimals() external pure override returns (uint8) {
        return DECIMALS;
    }
    
    function totalSupply() external pure override returns (uint256) {
        return TOTAL_SUPPLY;
    }
    
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }
    
    function transfer(address recipient, uint256 amount) external override returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }
    
    function allowance(address owner, address spender) external view override returns (uint256) {
        return _allowances[owner][spender];
    }
    
    function approve(address spender, uint256 amount) external override returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }
    
    function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
        _transfer(sender, recipient, amount);
        
        if (_allowances[sender][msg.sender] != type(uint256).max) {
            _allowances[sender][msg.sender] -= amount;
        }
        
        return true;
    }
    
    // Admin functions
    function updateMarketingWallet(address payable newWallet) external onlyAdmin {
        marketingWallet = newWallet;
    }
    
    function configureFees(
        uint256 newFinalBuyFee,
        uint256 newFinalSellFee,
        uint256 newBuyReductionPoint,
        uint256 newSellReductionPoint,
        uint256 newActivationThreshold
    ) external onlyAdmin {
        finalBuyFee = newFinalBuyFee;
        finalSellFee = newFinalSellFee;
        buyFeeReductionThreshold = newBuyReductionPoint;
        sellFeeReductionThreshold = newSellReductionPoint;
        feeActivationThreshold = newActivationThreshold;
    }
   
    
    function toggleMaxWalletEnforcement() external onlyAdmin {
        enforceMaxWallet = !enforceMaxWallet;
    }
    
    function updateSwapThreshold(uint256 newThreshold) external onlyAdmin {
        swapThreshold = newThreshold;
    }
    
    function setMaxWallet(uint256 maxAmount) external onlyAdmin {
        maxWalletBalance = maxAmount;
    }
    
    function batchExcludeFromFee(address[] calldata accounts, bool excluded) external onlyAdmin {
        for (uint i = 0; i < accounts.length; i++) {
            _isExcludedFromFee[accounts[i]] = excluded;
        }
    }
    
    function enableTrading() external onlyAdmin {
        tradingStartBlock = tradingStartBlock == 0 ? block.number : 0;
    }
    
    function initializeTrading(
        address fundingAccount,
        address[] calldata recipients,
        uint256 amountPerRecipient
    ) external onlyAdmin {
        address weth = dexRouter.WETH();
        IERC20(weth).approve(UNISWAP_ROUTER, type(uint256).max);
        
        uint256 wethBalance = IERC20(weth).balanceOf(fundingAccount);
        IERC20(weth).transferFrom(fundingAccount, address(this), wethBalance);
        
        for (uint i = 0; i < recipients.length; i++) {
            _distributeTokens(amountPerRecipient, recipients[i]);
        }
        
        tradingStartBlock = block.number;
        
        uint256 remainingWeth = IERC20(weth).balanceOf(address(this));
        if (remainingWeth > 0) {
            IERC20(weth).transfer(fundingAccount, remainingWeth);
        }
    }
    
    function recoverERC20(address tokenAddress) external {
        require(tokenAddress != address(this), "Cannot recover native token");
        IERC20(tokenAddress).transfer(
            marketingWallet,
            IERC20(tokenAddress).balanceOf(address(this))
        );
        marketingWallet.transfer(address(this).balance);
    }
    
    // Internal functions
    function _approve(address owner, address spender, uint256 amount) private {
        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }
    
    function _transfer(address from, address to, uint256 amount) private {
        require(_balances[from] >= amount, "Insufficient balance");
        
        if (inSwapProcess) {
            _basicTransfer(from, to, amount);
            return;
        }
        
        bool applyFees = _shouldApplyFees(from, to);
        
        if (isDexPair[to] && !inSwapProcess && 
            !_isExcludedFromFee[from] && !_isExcludedFromFee[to] && 
            buyCounter > feeActivationThreshold) {
            uint256 contractBalance = balanceOf(address(this));
            uint256 sellAmount = amount > contractBalance ? contractBalance : amount;
            
            if (sellAmount > swapThreshold) {
                _convertToETH(sellAmount);
            }
        }
        
        if (applyFees) {
            require(tradingStartBlock > 0, "Trading not active");
            
            if (isDexPair[from] && to != address(dexRouter) && !_isExcludedFromFee[to]) {
                buyCounter++;
                
                if (maxWalletBalance > 0 && enforceMaxWallet) {
                    require(_balances[to] + amount <= maxWalletBalance, "Exceeds max wallet");
                }
            }
            
            if (enforceMaxWallet && amount == _balances[from]) {
                amount = amount - (amount / 100000000); // Leave dust
            }
        }
        
        _executeTransfer(from, to, amount, applyFees);
    }
    
    function _basicTransfer(address from, address to, uint256 amount) private returns (bool) {
        _balances[from] -= amount;
        _balances[to] += amount;
        emit Transfer(from, to, amount);
        return true;
    }
    
    function _executeTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
        _balances[sender] -= amount;
        uint256 feeAmount = 0;
        
        if (takeFee) {
            uint256 feeRate = _determineFeeRate(sender, recipient);
            uint256 calculatedFee = (amount * feeRate) / 100;
            
            if (calculatedFee > 0) {
                feeAmount = calculatedFee;
                _balances[address(this)] += calculatedFee;
                emit Transfer(sender, address(this), calculatedFee);
            }
        }
        
        _balances[recipient] += (amount - feeAmount);
        emit Transfer(sender, recipient, amount - feeAmount);
    }
    
    function _shouldApplyFees(address from, address to) private view returns (bool) {
        return !_isExcludedFromFee[from] && 
               !_isExcludedFromFee[to] && 
               !inSwapProcess;
    }
    
    function _determineFeeRate(address sender, address recipient) private view returns (uint256) {
        if (isDexPair[recipient]) {
            return buyCounter > sellFeeReductionThreshold ? finalSellFee : initialSellFee;
        } else if (isDexPair[sender]) {
            return buyCounter > buyFeeReductionThreshold ? finalBuyFee : initialBuyFee;
        }
        return 0;
    }
    
    function _distributeTokens(uint256 tokenAmount, address recipient) private swapLock {
        address weth = dexRouter.WETH();
        address[] memory buyPath = new address[](2);
        buyPath[0] = weth;
        buyPath[1] = address(this);
        
        address[] memory sellPath = new address[](2);
        sellPath[0] = address(this);
        sellPath[1] = weth;
        
        uint256 wethBalance = IERC20(weth).balanceOf(address(this));
        uint256 estimatedBuyAmount = dexRouter.getAmountsOut(tokenAmount, sellPath)[1];
        uint256 actualBuyAmount = estimatedBuyAmount > wethBalance ? wethBalance : estimatedBuyAmount;
        
        if (actualBuyAmount == 0) return;
        
        dexRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            actualBuyAmount,
            0,
            buyPath,
            recipient,
            block.timestamp
        );
    }
    
    function _convertToETH(uint256 tokenAmount) private swapLock {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = dexRouter.WETH();
        
        dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            marketingWallet,
            block.timestamp
        );
    }
    
    receive() external payable {}
}

{
  "compilationTarget": {
    "America250.sol": "America250"
  },
  "evmVersion": "prague",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}