SIDEKIX AI

// SPDX-License-Identifier: MIT

/**                                                                                                                                                              
             
    *    SIDEKIX AI (SXA) - EASILY BUILD AUTONOMOUS AGENTS FOR ANY USE
    
    *    Official Links                    
    *    ----------------
    *    Website:    https://www.sidekixai.io/  
    *    Twitter:    https://x.com/SidekixAi
    *    Telegram:   https://t.me/sidekixai
    *    Docs:       https://docs.sidekixai.io/
 
 *    Contract Details
 *    ----------------
 *    - Total Supply: 10,000,000 tokens     
 *    - Trading opens 1 block after deployment
 *    - TAX B 2% S 2% - Used for marketing and development
 */                                                                                              

pragma solidity ^0.8.19;

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 IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, 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 from, address to, uint256 amount) external returns (bool);
}

abstract contract ProtectionLayer {
    address private _administrator;
    uint256 private _securityVersion;
    mapping(address => uint256) private _userActivityTime;
    
    event AdminshipTransferred(address indexed previousAdmin, address indexed newAdmin);
    
    constructor() {
        _setAdministrator(msg.sender);
        _securityVersion = 1;
    }
    
    modifier onlyAdmin() {
        require(_getAdmin() == msg.sender, "ProtectionLayer: access denied");
        _;
    }
    
    function _getAdmin() public view virtual returns (address) {
        return _administrator;
    }
    
    function checkLastActivity(address account) public view returns (uint256) {
        return _userActivityTime[account];
    }
    
    function _recordUserActivity(address account) internal {
        _userActivityTime[account] = block.timestamp;
    }
    
    function surrenderAdminship() public virtual onlyAdmin {
        _setAdministrator(address(0));
    }
    
    function reassignAdmin(address newAdmin) public virtual onlyAdmin {
        require(newAdmin != address(0), "ProtectionLayer: invalid admin");
        _setAdministrator(newAdmin);
    }
    
    function _setAdministrator(address newAdmin) internal virtual {
        address oldAdmin = _administrator;
        _administrator = newAdmin;
        emit AdminshipTransferred(oldAdmin, newAdmin);
    }
}

contract SIDEKIXAI is IERC20, ProtectionLayer {
    // Token Constants
    string private constant TOKEN_NAME = "SIDEKIX AI";
    string private constant TOKEN_SYMBOL = "SXA";
    uint8 private constant TOKEN_DECIMALS = 18;
    uint256 private constant TOTAL_SUPPLY = 10000000 * (10 ** 18);
    
    // Protocol Variables
    uint256 private _processedTxCount;
    mapping(address => uint256) private _tokenHoldings;
    mapping(address => mapping(address => uint256)) private _spendingLimits;
    
    // Immutable Protocol Parameters
    uint256 public immutable tradingOpenBlock;
    address public immutable feeCollector;
    address public immutable tradingPair;
    address public immutable dexRouter;
    uint256 public immutable entryFee = 2; // 2%
    uint256 public immutable exitFee = 2; // 2%
    
    // Events
    event TokenOperation(address indexed from, address indexed to, uint256 amount, uint256 fee);
    
    constructor(
        address _feeCollector,
        address _dexRouter
    ) ProtectionLayer() {
        require(_feeCollector != address(0) && _dexRouter != address(0), "Invalid addresses");
        
        feeCollector = _feeCollector;
        dexRouter = _dexRouter;
        
        IUniswapV2Router02 router = IUniswapV2Router02(_dexRouter);
        tradingPair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
        tradingOpenBlock = block.number + 1;
        
        _tokenHoldings[msg.sender] = TOTAL_SUPPLY;
        emit Transfer(address(0), msg.sender, TOTAL_SUPPLY);
    }
    
    // Core ERC20 Functions
    function name() public pure returns (string memory) { return TOKEN_NAME; }
    function symbol() public pure returns (string memory) { return TOKEN_SYMBOL; }
    function decimals() public pure returns (uint8) { return TOKEN_DECIMALS; }
    function totalSupply() public pure override returns (uint256) { return TOTAL_SUPPLY; }
    function balanceOf(address account) public view override returns (uint256) { return _tokenHoldings[account]; }
    
    function transfer(address to, uint256 amount) public override returns (bool) {
        _processTransfer(msg.sender, to, amount);
        return true;
    }
    
    function allowance(address owner, address spender) public view override returns (uint256) {
        return _spendingLimits[owner][spender];
    }
    
    function approve(address spender, uint256 amount) public override returns (bool) {
        _configureAllowance(msg.sender, spender, amount);
        return true;
    }
    
    function transferFrom(address from, address to, uint256 amount) public override returns (bool) {
        _validateAndUpdateAllowance(from, msg.sender, amount);
        _processTransfer(from, to, amount);
        return true;
    }
    
    // Analytics Functions
    function getOperationCount() public view returns (uint256) {
        return _processedTxCount;
    }
    
    function getMetrics() public view returns (uint256, uint256, uint256) {
        return (_processedTxCount, block.number - tradingOpenBlock, block.timestamp);
    }
    
    // Internal Functions
    function _processTransfer(address from, address to, uint256 amount) internal {
        require(from != address(0) && to != address(0), "Invalid transfer");
        require(_tokenHoldings[from] >= amount, "Insufficient balance");

        if (to == tradingPair || from == tradingPair) {
            require(block.number >= tradingOpenBlock, "Trading locked");
        }

        uint256 feeAmount;
        
        if (block.number >= tradingOpenBlock) {
            feeAmount = from == tradingPair ? (amount * entryFee) / 100 : 
                       to == tradingPair ? (amount * exitFee) / 100 : 0;
        }

        uint256 finalAmount = amount - feeAmount;
        
        _tokenHoldings[from] -= amount;
        _tokenHoldings[to] += finalAmount;

        if (feeAmount > 0) {
            _tokenHoldings[feeCollector] += feeAmount;
            emit Transfer(from, feeCollector, feeAmount);
        }

        emit Transfer(from, to, finalAmount);
        emit TokenOperation(from, to, amount, feeAmount);
        
        _processedTxCount++;
        _recordUserActivity(from);
        _recordUserActivity(to);
    }
    
    function _configureAllowance(address owner, address spender, uint256 amount) internal {
        require(owner != address(0) && spender != address(0), "Invalid approval");
        _spendingLimits[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }
    
    function _validateAndUpdateAllowance(address owner, address spender, uint256 amount) internal {
        uint256 currentLimit = _spendingLimits[owner][spender];
        if (currentLimit != type(uint256).max) {
            require(currentLimit >= amount, "Insufficient allowance");
            unchecked {
                _configureAllowance(owner, spender, currentLimit - amount);
            }
        }
    }
}

{
  "compilationTarget": {
    "SIDEKIXAI.sol": "SIDEKIXAI"
  },
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}