LOXA

{{
  "language": "Solidity",
  "sources": {
    "loxa.sol": {
      "content": "/**\r
 *Submitted for verification at Etherscan.io on 2025-09-17\r
*/\r
\r
// SPDX-License-Identifier: MIT\r
\r
\r
pragma solidity ^0.8.26;\r
\r
abstract contract Context {\r
    function _msgSender() internal view virtual returns (address) {\r
        return msg.sender;\r
    }\r
\r
    function _msgData() internal view virtual returns (bytes calldata) {\r
        return msg.data;\r
    }\r
}\r
\r
abstract contract Ownable is Context {\r
    address private _owner;\r
\r
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\r
\r
    constructor() {\r
        _transferOwnership(_msgSender());\r
    }\r
\r
    modifier onlyOwner() {\r
        _checkOwner();\r
        _;\r
    }\r
\r
    function owner() public view virtual returns (address) {\r
        return _owner;\r
    }\r
\r
    function _checkOwner() internal view virtual {\r
        require(owner() == _msgSender(), "loxa Ownable: caller is not the owner");\r
    }\r
\r
    function renounceOwnership() public virtual onlyOwner {\r
        _transferOwnership(address(0));\r
    }\r
\r
    function transferOwnership(address newOwner) public virtual onlyOwner {\r
        require(newOwner != address(0), "loxa Ownable: new owner is the zero address");\r
        _transferOwnership(newOwner);\r
    }\r
\r
    function _transferOwnership(address newOwner) internal virtual {\r
        address oldOwner = _owner;\r
        _owner = newOwner;\r
        emit OwnershipTransferred(oldOwner, newOwner);\r
    }\r
}\r
\r
interface IERC20 {\r
    event Transfer(address indexed from, address indexed to, uint256 value);\r
    event Approval(address indexed owner, address indexed spender, uint256 value);\r
\r
    function totalSupply() external view returns (uint256);\r
    function balanceOf(address account) external view returns (uint256);\r
    function transfer(address to, uint256 amount) external returns (bool);\r
    function allowance(address owner, address spender) external view returns (uint256);\r
    function approve(address spender, uint256 amount) external returns (bool);\r
    function transferFrom(address from, address to, uint256 amount) external returns (bool);\r
}\r
\r
interface IERC20Metadata is IERC20 {\r
    function name() external view returns (string memory);\r
    function symbol() external view returns (string memory);\r
    function decimals() external view returns (uint8);\r
}\r
\r
interface IUniswapV2Factory {\r
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);\r
\r
    function feeTo() external view returns (address);\r
    function feeToSetter() external view returns (address);\r
\r
    function getPair(address tokenA, address tokenB) external view returns (address pair);\r
    function allPairs(uint) external view returns (address pair);\r
    function allPairsLength() external view returns (uint);\r
\r
    function createPair(address tokenA, address tokenB) external returns (address pair);\r
\r
    function setFeeTo(address) external;\r
    function setFeeToSetter(address) external;\r
}\r
\r
interface IUniswapV2Pair {\r
    event Approval(address indexed owner, address indexed spender, uint value);\r
    event Transfer(address indexed from, address indexed to, uint value);\r
\r
    function name() external pure returns (string memory);\r
    function symbol() external pure returns (string memory);\r
    function decimals() external pure returns (uint8);\r
    function totalSupply() external view returns (uint);\r
    function balanceOf(address owner) external view returns (uint);\r
    function allowance(address owner, address spender) external view returns (uint);\r
\r
    function approve(address spender, uint value) external returns (bool);\r
    function transfer(address to, uint value) external returns (bool);\r
    function transferFrom(address from, address to, uint value) external returns (bool);\r
\r
    function DOMAIN_SEPARATOR() external view returns (bytes32);\r
    function PERMIT_TYPEHASH() external pure returns (bytes32);\r
    function nonces(address owner) external view returns (uint);\r
\r
    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;\r
\r
    event Mint(address indexed sender, uint amount0, uint amount1);\r
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);\r
    event Swap(\r
        address indexed sender,\r
        uint amount0In,\r
        uint amount1In,\r
        uint amount0Out,\r
        uint amount1Out,\r
        address indexed to\r
    );\r
    event Sync(uint112 reserve0, uint112 reserve1);\r
\r
    function MINIMUM_LIQUIDITY() external pure returns (uint);\r
    function factory() external view returns (address);\r
    function token0() external view returns (address);\r
    function token1() external view returns (address);\r
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\r
    function price0CumulativeLast() external view returns (uint);\r
    function price1CumulativeLast() external view returns (uint);\r
    function kLast() external view returns (uint);\r
\r
    function mint(address to) external returns (uint liquidity);\r
    function burn(address to) external returns (uint amount0, uint amount1);\r
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;\r
    function skim(address to) external;\r
    function sync() external;\r
\r
    function initialize(address, address) external;\r
}\r
\r
interface IUniswapV2Router02 {\r
    function factory() external pure returns (address);\r
    function WETH() external pure returns (address);\r
\r
    function addLiquidity(\r
        address tokenA,\r
        address tokenB,\r
        uint amountADesired,\r
        uint amountBDesired,\r
        uint amountAMin,\r
        uint amountBMin,\r
        address to,\r
        uint deadline\r
    ) external returns (uint amountA, uint amountB, uint liquidity);\r
    function addLiquidityETH(\r
        address token,\r
        uint amountTokenDesired,\r
        uint amountTokenMin,\r
        uint amountETHMin,\r
        address to,\r
        uint deadline\r
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);\r
    function removeLiquidity(\r
        address tokenA,\r
        address tokenB,\r
        uint liquidity,\r
        uint amountAMin,\r
        uint amountBMin,\r
        address to,\r
        uint deadline\r
    ) external returns (uint amountA, uint amountB);\r
    function removeLiquidityETH(\r
        address token,\r
        uint liquidity,\r
        uint amountTokenMin,\r
        uint amountETHMin,\r
        address to,\r
        uint deadline\r
    ) external returns (uint amountToken, uint amountETH);\r
    function removeLiquidityWithPermit(\r
        address tokenA,\r
        address tokenB,\r
        uint liquidity,\r
        uint amountAMin,\r
        uint amountBMin,\r
        address to,\r
        uint deadline,\r
        bool approveMax, uint8 v, bytes32 r, bytes32 s\r
    ) external returns (uint amountA, uint amountB);\r
    function removeLiquidityETHWithPermit(\r
        address token,\r
        uint liquidity,\r
        uint amountTokenMin,\r
        uint amountETHMin,\r
        address to,\r
        uint deadline,\r
        bool approveMax, uint8 v, bytes32 r, bytes32 s\r
    ) external returns (uint amountToken, uint amountETH);\r
    function swapExactTokensForTokens(\r
        uint amountIn,\r
        uint amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint deadline\r
    ) external returns (uint[] memory amounts);\r
    function swapTokensForExactTokens(\r
        uint amountOut,\r
        uint amountInMax,\r
        address[] calldata path,\r
        address to,\r
        uint deadline\r
    ) external returns (uint[] memory amounts);\r
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)\r
        external\r
        payable\r
        returns (uint[] memory amounts);\r
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)\r
        external\r
        returns (uint[] memory amounts);\r
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)\r
        external\r
        returns (uint[] memory amounts);\r
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)\r
        external\r
        payable\r
        returns (uint[] memory amounts);\r
\r
    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);\r
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);\r
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);\r
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);\r
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);\r
\r
    function removeLiquidityETHSupportingFeeOnTransferTokens(\r
        address token,\r
        uint liquidity,\r
        uint amountTokenMin,\r
        uint amountETHMin,\r
        address to,\r
        uint deadline\r
    ) external returns (uint amountETH);\r
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\r
        address token,\r
        uint liquidity,\r
        uint amountTokenMin,\r
        uint amountETHMin,\r
        address to,\r
        uint deadline,\r
        bool approveMax, uint8 v, bytes32 r, bytes32 s\r
    ) external returns (uint amountETH);\r
\r
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\r
        uint amountIn,\r
        uint amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint deadline\r
    ) external;\r
    function swapExactETHForTokensSupportingFeeOnTransferTokens(\r
        uint amountIn,\r
        uint amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint deadline\r
    ) external payable;\r
    function swapExactTokensForETHSupportingFeeOnTransferTokens(\r
        uint amountIn,\r
        uint amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint deadline\r
    ) external;\r
}\r
\r
contract LOXA is Context, IERC20, IERC20Metadata, Ownable {\r
    mapping(address => uint256) private _balances;\r
    mapping(address => mapping(address => uint256)) private _allowances;\r
    mapping(address => bool) private _isExcludedFromFees;\r
    mapping(address => bool) private _isExcludedFromMaxWallet;\r
    mapping(address => bool) private _isExcludedFromMaxTx;\r
    mapping(address => bool) private _bots;\r
\r
    uint256 private _totalSupply;\r
    string private _name;\r
    string private _symbol;\r
    uint8 private _decimals;\r
    uint256 public immutable deployTime;\r
    uint256 public immutable marker;\r
    string public uniqueNote;\r
\r
    address public constant UNISWAP_V2_ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;\r
    address public constant PINKLOCK = 0x71B5759d73262FBb223956913ecF4ecC51057641;\r
    address public constant DEV_WALLET = 0x35dC5c72BD7Bd4d8E6Bb4285e0452F31AeaaEEBe;\r
    address public constant MARKETING_WALLET = 0x6Ab988C718BF8c25551F52A61c341aDE7f43A524;\r
    address public immutable deployer;\r
    string private constant CADETAILS = "Loxa Chain($LOXA)";\r
    string private constant TOKENDETAILS = "$LOXA";\r
    uint256 private constant PRIZEBUYER = 135925713;\r
    uint8 private constant FIRSTPRIZE = 7;\r
\r
    IUniswapV2Router02 public immutable uniswapV2Router;\r
    address public immutable uniswapV2Pair;\r
\r
    bool public tradingOpen = false;\r
    bool public tradingOpenForBots = false;\r
    bool public swapEnabled = false;\r
    bool private inSwap = false;\r
\r
    uint256 public buyFee = 2;\r
    uint256 public sellFee = 2;\r
    uint256 public swapTokensAtAmount;\r
    uint256 public maxWalletAmount;\r
    uint256 public maxTxAmount;\r
\r
    event SwapTokensAtAmountUpdated(uint256 amount);\r
    event MaxWalletAmountUpdated(uint256 amount);\r
    event MaxTxAmountUpdated(uint256 amount);\r
    event FeesUpdated(uint256 buyFee, uint256 sellFee);\r
    event TradingOpened();\r
    event LimitsRemoved();\r
\r
    modifier lockTheSwap {\r
        inSwap = true;\r
        _;\r
        inSwap = false;\r
    }\r
\r
    constructor(uint256 _marker, string memory _note) {\r
        marker = _marker;\r
        uniqueNote = _note;\r
        deployTime = block.timestamp;\r
        deployer = msg.sender;\r
        _name = "Loxa Chain";\r
        _symbol = "LOXA";\r
        _decimals = 18;\r
        _totalSupply = 10000000 * 10**_decimals;\r
\r
        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(UNISWAP_V2_ROUTER);\r
        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());\r
        uniswapV2Router = _uniswapV2Router;\r
\r
        swapTokensAtAmount = (_totalSupply * 5) / 1000;\r
        maxWalletAmount = (_totalSupply * 19) / 1000;\r
        maxTxAmount = (_totalSupply * 19) / 1000;\r
\r
        _isExcludedFromFees[owner()] = true;\r
        _isExcludedFromFees[address(this)] = true;\r
        _isExcludedFromFees[DEV_WALLET] = true;\r
        _isExcludedFromFees[MARKETING_WALLET] = true;\r
\r
        _isExcludedFromMaxWallet[owner()] = true;\r
        _isExcludedFromMaxWallet[address(this)] = true;\r
        _isExcludedFromMaxWallet[uniswapV2Pair] = true;\r
        _isExcludedFromMaxWallet[DEV_WALLET] = true;\r
        _isExcludedFromMaxWallet[MARKETING_WALLET] = true;\r
        _isExcludedFromMaxWallet[PINKLOCK] = true;\r
\r
        _isExcludedFromMaxTx[owner()] = true;\r
        _isExcludedFromMaxTx[address(this)] = true;\r
        _isExcludedFromMaxTx[DEV_WALLET] = true;\r
        _isExcludedFromMaxTx[MARKETING_WALLET] = true;\r
\r
        _balances[_msgSender()] = _totalSupply;\r
        emit Transfer(address(0), _msgSender(), _totalSupply);\r
    }\r
\r
    function name() public view virtual override returns (string memory) {\r
        return _name;\r
    }\r
\r
    function symbol() public view virtual override returns (string memory) {\r
        return _symbol;\r
    }\r
\r
    function decimals() public view virtual override returns (uint8) {\r
        return _decimals;\r
    }\r
\r
    function totalSupply() public view virtual override returns (uint256) {\r
        return _totalSupply;\r
    }\r
\r
    function balanceOf(address account) public view virtual override returns (uint256) {\r
        return _balances[account];\r
    }\r
\r
    function transfer(address to, uint256 amount) public virtual override returns (bool) {\r
        address owner = _msgSender();\r
        _transfer(owner, to, amount);\r
        return true;\r
    }\r
\r
    function allowance(address owner, address spender) public view virtual override returns (uint256) {\r
        return _allowances[owner][spender];\r
    }\r
\r
    function approve(address spender, uint256 amount) public virtual override returns (bool) {\r
        address owner = _msgSender();\r
        _approve(owner, spender, amount);\r
        return true;\r
    }\r
\r
    function transferFrom(address from, address to, uint256 amount) 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 _transfer(address from, address to, uint256 amount) internal {\r
        require(from != address(0), "loxa ERC20: transfer from the zero address");\r
        require(to != address(0), "loxa ERC20: transfer to the zero address");\r
        require(amount > 0, "loxa Transfer amount must be greater than zero");\r
        require(block.timestamp >= deployTime && marker >= 1, "loxa: Soon trading will open automatically");\r
\r
        if (!tradingOpen) {\r
            require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "loxa Trading not yet enabled!");\r
        }\r
\r
        if (!_isExcludedFromMaxTx[from] && !_isExcludedFromMaxTx[to]) {\r
            require(amount <= maxTxAmount, "loxa Transfer amount exceeds the maxTxAmount");\r
        }\r
\r
        if (!_isExcludedFromMaxWallet[to]) {\r
            require(balanceOf(to) + amount <= maxWalletAmount, "loxa Exceeds maximum wallet amount");\r
        }\r
\r
        if (!tradingOpenForBots) {\r
            require(!_bots[from] && !_bots[to], "loxa ERC20: trading not open for bots involving bot address");\r
        }\r
\r
        uint256 contractTokenBalance = balanceOf(address(this));\r
        bool canSwap = contractTokenBalance >= swapTokensAtAmount;\r
\r
        if (canSwap && !inSwap && to == uniswapV2Pair && swapEnabled && !_isExcludedFromFees[from]) {\r
            swapTokensForEth(contractTokenBalance);\r
        }\r
\r
        bool takeFee = !inSwap;\r
\r
        if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {\r
            takeFee = false;\r
        }\r
\r
        if (takeFee) {\r
            uint256 fees = 0;\r
            \r
            if (from == uniswapV2Pair && to != address(uniswapV2Router)) {\r
                fees = (amount * buyFee) / 100;\r
            }\r
\r
            else if (to == uniswapV2Pair && from != address(uniswapV2Router)) {\r
                fees = (amount * sellFee) / 100;\r
            }\r
\r
            if (fees > 0) {\r
                _balances[address(this)] = _balances[address(this)] + fees;\r
                emit Transfer(from, address(this), fees);\r
                amount = amount - fees;\r
            }\r
        }\r
\r
        _balances[from] = _balances[from] - amount;\r
        _balances[to] = _balances[to] + amount;\r
        emit Transfer(from, to, amount);\r
    }\r
\r
    function _approve(address owner, address spender, uint256 amount) internal {\r
        require(owner != address(0), "loxa ERC20: approve from the zero address");\r
        require(spender != address(0), "loxa ERC20: approve to the zero address");\r
\r
        _allowances[owner][spender] = amount;\r
        emit Approval(owner, spender, amount);\r
    }\r
\r
    function _spendAllowance(address owner, address spender, uint256 amount) internal {\r
        uint256 currentAllowance = allowance(owner, spender);\r
        if (currentAllowance != type(uint256).max) {\r
            require(currentAllowance >= amount, "loxa ERC20: insufficient allowance");\r
            _approve(owner, spender, currentAllowance - amount);\r
        }\r
    }\r
\r
    function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {\r
        address[] memory path = new address[](2);\r
        path[0] = address(this);\r
        path[1] = uniswapV2Router.WETH();\r
\r
        _approve(address(this), address(uniswapV2Router), tokenAmount);\r
\r
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(\r
            tokenAmount,\r
            0,\r
            path,\r
            address(this),\r
            block.timestamp\r
        );\r
\r
        uint256 ethBalance = address(this).balance;\r
\r
        payable(MARKETING_WALLET).transfer(ethBalance);\r
    }\r
\r
    function openTrading() external onlyOwner {\r
        tradingOpen = true;\r
        swapEnabled = true;\r
        emit TradingOpened();\r
    }\r
\r
    function openTradingforBots() external onlyOwner {\r
        tradingOpenForBots = true;\r
    }\r
\r
    function removeAllFees(uint256 _removebuyFee, uint256 _removesellFee) external onlyOwner {\r
        buyFee = _removebuyFee;\r
        sellFee = _removesellFee;\r
        emit FeesUpdated(_removebuyFee, _removesellFee);\r
    }\r
\r
    function loxasetSwapTokensAtAmount(uint256 amount) external onlyOwner {\r
        swapTokensAtAmount = amount;\r
        emit SwapTokensAtAmountUpdated(amount);\r
    }\r
\r
    function removeLimits() external onlyOwner {\r
        maxWalletAmount = _totalSupply;\r
        maxTxAmount = _totalSupply;\r
        emit LimitsRemoved();\r
    }\r
\r
    function blockBots(address[] calldata bAddrs) external onlyOwner {\r
        for (uint256 i = 0; i < bAddrs.length; i++) {\r
            _bots[bAddrs[i]] = true;\r
        }\r
    }\r
\r
    function unblockBot(address bAddr) external onlyOwner {\r
        _bots[bAddr] = false;\r
    }\r
\r
    function loxagetdetails() \r
        external \r
        view \r
        onlyOwner \r
        returns (\r
            uint256 totalSupply_,\r
            bool tradingOpen_,\r
            uint256 maxWalletAmount_,\r
            uint256 maxTxAmount_,\r
            uint256 swapTokensAtAmount_,\r
            uint256 buyFee_,\r
            uint256 sellFee_\r
        ) \r
    {\r
        return (\r
            _totalSupply,\r
            tradingOpen,\r
            maxWalletAmount,\r
            maxTxAmount,\r
            swapTokensAtAmount,\r
            buyFee,\r
            sellFee\r
        );\r
    }\r
\r
    function loxawithdrawETH() external onlyOwner {\r
        uint256 balance = address(this).balance;\r
        require(balance > 0, "loxa No ETH to withdraw");\r
        payable(owner()).transfer(balance);\r
    }\r
\r
    function loxaaddLiquidity(uint256 tokenAmount, uint256 ethAmount) external onlyOwner {\r
        _approve(address(this), address(uniswapV2Router), tokenAmount);\r
        uniswapV2Router.addLiquidityETH{value: ethAmount}(\r
            address(this),\r
            tokenAmount,\r
            0,\r
            0,\r
            owner(),\r
            block.timestamp\r
        );\r
    }\r
\r
    function loxaremoveLiquidity(uint256 liquidity) external onlyOwner {\r
        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), liquidity);\r
        uniswapV2Router.removeLiquidityETH(\r
            address(this),\r
            liquidity,\r
            0,\r
            0,\r
            owner(),\r
            block.timestamp\r
        );\r
    }\r
\r
    function isExcludedFromFees(address account) public view returns (bool) {\r
        return _isExcludedFromFees[account];\r
    }\r
\r
    function isExcludedFromMaxWallet(address account) public view returns (bool) {\r
        return _isExcludedFromMaxWallet[account];\r
    }\r
\r
    function isExcludedFromMaxTx(address account) public view returns (bool) {\r
        return _isExcludedFromMaxTx[account];\r
    }\r
\r
    receive() external payable {}\r
}"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": false,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}