/**
 *Submitted for verification at Etherscan.io on 2024-09-20
 */

/**

    ███╗░░██╗██╗░░░██╗██╗░░██╗░█████╗░██╗██████╗░██╗░░██╗███████╗██████╗░
    ████╗░██║╚██╗░██╔╝╚██╗██╔╝██╔══██╗██║██╔══██╗██║░░██║██╔════╝██╔══██╗
    ██╔██╗██║░╚████╔╝░░╚███╔╝░██║░░╚═╝██║██████╔╝███████║█████╗░░██████╔╝
    ██║╚████║░░╚██╔╝░░░██╔██╗░██║░░██╗██║██╔═══╝░██╔══██║██╔══╝░░██╔══██╗
    ██║░╚███║░░░██║░░░██╔╝╚██╗╚█████╔╝██║██║░░░░░██║░░██║███████╗██║░░██║
    ╚═╝░░╚══╝░░░╚═╝░░░╚═╝░░╚═╝░╚════╝░╚═╝╚═╝░░░░░╚═╝░░╚═╝╚══════╝╚═╝░░╚═╝

    𝙰𝚗 𝙰𝙸-𝚙𝚘𝚠𝚎𝚛𝚎𝚍 𝚂𝚘𝚕𝚒𝚍𝚒𝚝𝚢 𝚂𝚖𝚊𝚛𝚝 𝙲𝚘𝚗𝚝𝚛𝚊𝚌𝚝 𝙰𝚞𝚍𝚒𝚝𝚘𝚛 𝚝𝚑𝚊𝚝 𝚞𝚜𝚎𝚜 𝙰𝙸 𝚝𝚘 𝚊𝚗𝚊𝚕𝚢𝚣𝚎 𝚊𝚗𝚍 𝚊𝚞𝚍𝚒𝚝 𝚜𝚖𝚊𝚛𝚝 
    𝚌𝚘𝚗𝚝𝚛𝚊𝚌𝚝 𝚌𝚘𝚍𝚎, 𝚏𝚒𝚗𝚍𝚜 𝚎𝚛𝚛𝚘𝚛𝚜 𝚊𝚗𝚍 𝚟𝚞𝚕𝚗𝚎𝚛𝚊𝚋𝚒𝚕𝚒𝚝𝚒𝚎𝚜, 𝚊𝚗𝚍 𝚙𝚛𝚘𝚟𝚒𝚍𝚎𝚜 𝚍𝚎𝚝𝚊𝚒𝚕𝚎𝚍 𝚛𝚎𝚙𝚘𝚛𝚝𝚜 𝚏𝚘𝚛 
    𝚜𝚎𝚌𝚞𝚛𝚎 𝚊𝚗𝚍 𝚎𝚛𝚛𝚘𝚛-𝚏𝚛𝚎𝚎 𝚜𝚖𝚊𝚛𝚝 𝚌𝚘𝚗𝚝𝚛𝚊𝚌𝚝𝚜.

    Home Page

    https://nyxcipher.ai/

    Web App

    https://app.nyxcipher.ai/

    Join our Telegram!

    https://t.me/nyxcipherportal

    Twitter

    https://x.com/nyxcipherai


*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function decimals() external view returns (uint8);
    function symbol() external view returns (string memory);
    function name() external view returns (string memory);
    function getOwner() external view returns (address);
    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 IFactoryV2 {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address lpPair,
        uint
    );
    function getPair(
        address tokenA,
        address tokenB
    ) external view returns (address lpPair);
    function createPair(
        address tokenA,
        address tokenB
    ) external returns (address lpPair);
}

interface IV2Pair {
    function factory() external view returns (address);
    function getReserves()
        external
        view
        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function sync() external;
}

interface IRouter01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    )
        external
        payable
        returns (uint amountToken, uint amountETH, uint liquidity);
    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function swapExactETHForTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable returns (uint[] memory amounts);
    function getAmountsOut(
        uint amountIn,
        address[] calldata path
    ) external view returns (uint[] memory amounts);
    function getAmountsIn(
        uint amountOut,
        address[] calldata path
    ) external view returns (uint[] memory amounts);
}

interface IRouter02 is IRouter01 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
}

interface Initializer {
    function setLaunch(
        address _initialLpPair,
        uint32 _liqAddBlock,
        uint64 _liqAddStamp,
        uint8 dec
    ) external;
    function getConfig() external returns (address, address);
    function getInits(uint256 amount) external returns (uint256, uint256);
    function setLpPair(address pair, bool enabled) external;
}

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;
        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        return c;
    }
}

contract NyxCipher is IERC20 {
    using SafeMath for uint256;
    mapping(address => uint256) private _tOwned;
    mapping(address => bool) lpPairs;
    uint256 private timeSinceLastPair = 0;
    mapping(address => mapping(address => uint256)) private _allowances;
    mapping(address => bool) private _liquidityHolders;
    mapping(address => bool) private _isExcludedFromProtection;
    mapping(address => bool) private _isExcludedFromFees;
    uint256 private constant startingSupply = 100_000_000;
    string private constant _name = "NYX CIPHER";
    string private constant _symbol = "$NXCP";
    uint8 private constant _decimals = 8;
    uint256 private constant _tTotal = startingSupply * 10 ** _decimals;

    // Add these as state variables
    uint256 public constant initialTaxRate = 2500; // 25%
    uint256 public constant finalTaxRate = 500;    // 5%
    uint256 public constant taxReductionPerMinute = 500; // 5% reduction per minute
    uint256 public constant maxReductionMinutes = 4;     // Tax reduces for 4 minutes (25% -> 5%)


    struct Fees {
        uint16 buyFee;
        uint16 sellFee;
        uint16 transferFee;
    }

    struct Ratios {
        uint16 marketing;
        uint16 development;
        uint16 buyBackBurnLP;
        uint16 totalSwap;
    }
    // Define the Lock struct to store the amount and release time of locked tokens
    struct Lock {
        uint256 totalAmount;  // Total tokens to be vested/locked
        uint256 releaseTime;  // Time when initial lock period ends
        uint256 vestingStart; // When vesting starts (after lock period)
        uint256 vestingDuration;  // Total duration for linear vesting
        uint256 claimed;  // Tokens that have been claimed already
    }
    // Set the vesting parameters
    uint256 public constant TEAM_LOCK_PERIOD = 90 days;  // 3 months lock period
    uint256 public constant TEAM_VESTING_DURATION = 720 days;  // 24 months for vesting


    Fees public _taxRates = Fees({buyFee: 500, sellFee: 500, transferFee: 0});

    Ratios public _ratios =
        Ratios({
            marketing: 2,
            development: 2,
            buyBackBurnLP: 1,
            totalSwap: 5
        });

    uint256 public constant maxBuyTaxes = 1000;
    uint256 public constant maxSellTaxes = 1000;
    uint256 public constant maxTransferTaxes = 1000;
    uint256 constant masterTaxDivisor = 10000;
    // Mapping to keep track of locked tokens and their release times for each address
    mapping(address => Lock) public lockedTokens;

    bool public taxesAreLocked;
    IRouter02 public dexRouter;
    address public lpPair;
    address public constant DEAD = 0x000000000000000000000000000000000000dEaD;

    struct TaxWallets {
        address payable marketing;
        address payable development;
        address payable buyBackBurnLP;
    }

    TaxWallets public _taxWallets =
        TaxWallets({
            marketing: payable(0x0000000000000000000000000000000000000000),
            development: payable(0x0000000000000000000000000000000000000000),
            buyBackBurnLP: payable(0x0000000000000000000000000000000000000000)
        });

    bool inSwap;
    bool public contractSwapEnabled = false;
    uint256 public swapThreshold = _tTotal / 10000;
    uint256 public swapAmount =  _tTotal / 10000;
    bool public piContractSwapsEnabled = false;
    uint256 public piSwapPercent = 10;
    bool public tradingEnabled = false;
    bool public _hasLiqBeenAdded = false;
    Initializer initializer;
    uint256 public launchStamp;

    uint256 public maxTransferAmount; // Maximum transfer amount (1% of total supply)
    uint256 public maxWalletAmount;   // Maximum wallet amount (1% of total supply)


    event ContractSwapEnabledUpdated(bool enabled);
    event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);

    modifier inSwapFlag() {
        inSwap = true;
        _;
        inSwap = false;
    }

    constructor(
        address payable marketingWallet,
        address payable developmentWallet,
        address payable buyBackBurnLPWallet,
        address payable teamFoundationWallet
    ) payable {
        // Set the owner.
        _owner = msg.sender;

        _tOwned[_owner] = _tTotal;
        emit Transfer(address(0), _owner, _tTotal);

        // Exclude certain addresses from fees
        _isExcludedFromFees[_owner] = true;
        _isExcludedFromFees[address(this)] = true;
        _isExcludedFromFees[DEAD] = true;
        _liquidityHolders[_owner] = true;

        _isExcludedFromFees[0x407993575c91ce7643a4d4cCACc9A98c36eE1BBE] = true; // PinkLock
        _isExcludedFromFees[0x663A5C229c09b049E36dCc11a9B0d4a8Eb9db214] = true; // Unicrypt (ETH)
        _isExcludedFromFees[0xDba68f07d1b7Ca219f78ae8582C213d975c25cAf] = true; // Unicrypt (ETH)

        // Set the tax wallets
        _taxWallets = TaxWallets({
            marketing: marketingWallet,
            development: developmentWallet,
            buyBackBurnLP: buyBackBurnLPWallet
        });

        // Distribute initial supply to designated wallets
        uint256 marketingTokens = (_tTotal * 10) / 100;
        uint256 developmentTokens = (_tTotal * 5) / 100;
        uint256 teamFoundationTokens = (_tTotal * 15) / 100;

        _tOwned[marketingWallet] = marketingTokens;
        _tOwned[developmentWallet] = developmentTokens;
        _tOwned[teamFoundationWallet] = teamFoundationTokens;

        // Set up the teamFoundationWallet's lock and vesting
        lockedTokens[teamFoundationWallet] = Lock({
            totalAmount: (_tTotal * 15) / 100,  // 15% of total supply
            releaseTime: block.timestamp + TEAM_LOCK_PERIOD,  // Lock for 3 months
            vestingStart: block.timestamp + TEAM_LOCK_PERIOD,  // Vesting starts after 3 months
            vestingDuration: TEAM_VESTING_DURATION,  // Linear vesting over 24 months
            claimed: 0  // No tokens claimed initially
        });
        
        // Initialize max transfer and holding limits as 1% of total supply
        maxTransferAmount = _tTotal / 100; // 1% of total supply
        maxWalletAmount = _tTotal / 100;   // 1% of total supply

        // Adjust owner's balance
        _tOwned[_owner] = _tTotal - (marketingTokens + developmentTokens + teamFoundationTokens);
        emit Transfer(_owner, marketingWallet, marketingTokens);
        emit Transfer(_owner, developmentWallet, developmentTokens);
        emit Transfer(_owner, teamFoundationWallet, teamFoundationTokens);
    }
    //===============================================================================================================
    //===============================================================================================================
    //===============================================================================================================
    // Ownable removed as a lib and added here to allow for custom transfers and renouncements.
    // This allows for removal of ownership privileges from the owner once renounced or transferred.

    address private _owner;

    modifier onlyOwner() {
        require(_owner == msg.sender, "Caller =/= owner.");
        _;
    }
    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

    function transferOwner(address newOwner) external onlyOwner {
        require(
            newOwner != address(0),
            "Call renounceOwnership to transfer owner to the zero address."
        );
        require(
            newOwner != DEAD,
            "Call renounceOwnership to transfer owner to the zero address."
        );
        setExcludedFromFees(_owner, false);
        setExcludedFromFees(newOwner, true);

        if (balanceOf(_owner) > 0) {
            finalizeTransfer(
                _owner,
                newOwner,
                balanceOf(_owner),
                false,
                false,
                true
            );
        }

        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }

    function renounceOwnership() external onlyOwner {
        require(
            tradingEnabled,
            "Cannot renounce until trading has been enabled."
        );
        setExcludedFromFees(_owner, false);
        address oldOwner = _owner;
        _owner = address(0);
        emit OwnershipTransferred(oldOwner, address(0));
    }

    //===============================================================================================================
    //===============================================================================================================
    //===============================================================================================================

    receive() external payable {}
    function totalSupply() external pure override returns (uint256) {
        return _tTotal;
    }
    function decimals() external pure override returns (uint8) {
        return _decimals;
    }
    function symbol() external pure override returns (string memory) {
        return _symbol;
    }
    function name() external pure override returns (string memory) {
        return _name;
    }
    function getOwner() external view override returns (address) {
        return _owner;
    }
    function allowance(
        address holder,
        address spender
    ) external view override returns (uint256) {
        return _allowances[holder][spender];
    }
    function balanceOf(address account) public view override returns (uint256) {
        return _tOwned[account];
    }

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

    function approve(
        address spender,
        uint256 amount
    ) external override returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    function _approve(
        address sender,
        address spender,
        uint256 amount
    ) internal {
        require(sender != address(0), "ERC20: Zero Address");
        require(spender != address(0), "ERC20: Zero Address");

        _allowances[sender][spender] = amount;
        emit Approval(sender, spender, amount);
    }

    function approveContractContingency() external onlyOwner returns (bool) {
        _approve(address(this), address(dexRouter), type(uint256).max);
        return true;
    }


    function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
        if (_allowances[sender][msg.sender] != type(uint256).max) {
            _allowances[sender][msg.sender] -= _allowances[sender][msg.sender].sub(amount);
        }

        return _transfer(sender, recipient, amount);
    }

    function setNewRouter(address newRouter) external onlyOwner {
        require(!_hasLiqBeenAdded, "Cannot change after liquidity.");
        IRouter02 _newRouter = IRouter02(newRouter);
        address get_pair = IFactoryV2(_newRouter.factory()).getPair(
            address(this),
            _newRouter.WETH()
        );
        lpPairs[lpPair] = false;
        if (get_pair == address(0)) {
            lpPair = IFactoryV2(_newRouter.factory()).createPair(
                address(this),
                _newRouter.WETH()
            );
        } else {
            lpPair = get_pair;
        }
        dexRouter = _newRouter;
        lpPairs[lpPair] = true;
        _approve(address(this), address(dexRouter), type(uint256).max);
    }

    function setLpPair(address pair, bool enabled) external onlyOwner {
        if (!enabled) {
            lpPairs[pair] = false;
            initializer.setLpPair(pair, false);
        } else {
            if (timeSinceLastPair != 0) {
                require(
                    block.timestamp - timeSinceLastPair > 3 days,
                    "3 Day cooldown."
                );
            }
            require(!lpPairs[pair], "Pair already added to list.");
            lpPairs[pair] = true;
            timeSinceLastPair = block.timestamp;
            initializer.setLpPair(pair, true);
        }
    }

    function setInitializer(address init) public onlyOwner {
        require(!tradingEnabled);
        require(init != address(this), "Can't be self.");
        initializer = Initializer(init);
        try initializer.getConfig() returns (
            address router,
            address constructorLP
        ) {
            dexRouter = IRouter02(router);
            lpPair = constructorLP;
            lpPairs[lpPair] = true;
            _approve(_owner, address(dexRouter), type(uint256).max);
            _approve(address(this), address(dexRouter), type(uint256).max);
        } catch {
            revert();
        }
    }

    function isExcludedFromFees(address account) external view returns (bool) {
        return _isExcludedFromFees[account];
    }

    function setExcludedFromFees(
        address account,
        bool enabled
    ) public onlyOwner {
        _isExcludedFromFees[account] = enabled;
    }

    function isExcludedFromProtection(
        address account
    ) external view returns (bool) {
        return _isExcludedFromProtection[account];
    }

    function setExcludedFromProtection(
        address account,
        bool enabled
    ) external onlyOwner {
        _isExcludedFromProtection[account] = enabled;
    }

    function getCirculatingSupply() public view returns (uint256) {
        return (_tTotal - (balanceOf(DEAD) + balanceOf(address(0))));
    }

    function lockTaxes() external onlyOwner {
        // This will lock taxes at their current value forever, do not call this unless you're sure.
        taxesAreLocked = true;
    }

    function setTaxes(
        uint16 buyFee,
        uint16 sellFee,
        uint16 transferFee
    ) external onlyOwner {
        require(!taxesAreLocked, "Taxes are locked.");
        require(
            buyFee <= maxBuyTaxes &&
                sellFee <= maxSellTaxes &&
                transferFee <= maxTransferTaxes,
            "Cannot exceed maximums."
        );
        _taxRates.buyFee = buyFee;
        _taxRates.sellFee = sellFee;
        _taxRates.transferFee = transferFee;
    }

    function setRatios(
        uint16 marketing,
        uint16 development,
        uint16 buyBackBurnLP
    ) external onlyOwner {
        _ratios.marketing = marketing;
        _ratios.development = development;
        _ratios.buyBackBurnLP = buyBackBurnLP;
        _ratios.totalSwap = marketing + development + buyBackBurnLP;
        uint256 total = _taxRates.buyFee + _taxRates.sellFee;
        require(
            _ratios.totalSwap <= total,
            "Cannot exceed sum of buy and sell fees."
        );
    }

    function setWallets(
        address payable marketing,
        address payable development,
        address payable buyBackBurnLP
    ) external onlyOwner {
        require(
            marketing != address(0) &&
                development != address(0) &&
                buyBackBurnLP != address(0),
            "Cannot be zero address."
        );
        _taxWallets.marketing = payable(marketing);
        _taxWallets.development = payable(development);
        _taxWallets.buyBackBurnLP = payable(buyBackBurnLP);
    }

    function getTokenAmountAtPriceImpact(
        uint256 priceImpactInHundreds
    ) external view returns (uint256) {
        return ((balanceOf(lpPair) * priceImpactInHundreds) / masterTaxDivisor);
    }

    function setSwapSettings(
        uint256 thresholdPercent,
        uint256 thresholdDivisor,
        uint256 amountPercent,
        uint256 amountDivisor
    ) external onlyOwner {
        swapThreshold = (_tTotal * thresholdPercent) / thresholdDivisor;
        swapAmount = (_tTotal * amountPercent) / amountDivisor;
        require(
            swapThreshold <= swapAmount,
            "Threshold cannot be above amount."
        );
        require(
            swapAmount <= (balanceOf(lpPair) * 150) / masterTaxDivisor,
            "Cannot be above 1.5% of current PI."
        );
        require(
            swapAmount >= _tTotal / 1_000_000,
            "Cannot be lower than 0.00001% of total supply."
        );
        require(
            swapThreshold >= _tTotal / 1_000_000,
            "Cannot be lower than 0.00001% of total supply."
        );
    }

    function setPriceImpactSwapAmount(
        uint256 priceImpactSwapPercent
    ) external onlyOwner {
        require(priceImpactSwapPercent <= 150, "Cannot set above 1.5%.");
        piSwapPercent = priceImpactSwapPercent;
    }

    function setContractSwapEnabled(
        bool swapEnabled,
        bool priceImpactSwapEnabled
    ) external onlyOwner {
        contractSwapEnabled = swapEnabled;
        piContractSwapsEnabled = priceImpactSwapEnabled;
        emit ContractSwapEnabledUpdated(swapEnabled);
    }

    function _hasLimits(address from, address to) internal view returns (bool) {
        return
            from != _owner &&
            to != _owner &&
            tx.origin != _owner &&
            !_liquidityHolders[to] &&
            !_liquidityHolders[from] &&
            to != DEAD &&
            to != address(0) &&
            from != address(this) &&
            from != address(initializer) &&
            to != address(initializer);
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal returns (bool) {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        require(amount > 0, "Transfer amount must be greater than zero");

        // Check if the wallet is excluded from max transfer and max wallet restrictions
        if (!_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
            // Enforce the maximum transfer amount (only if not excluded)
            require(amount <= maxTransferAmount, "Transfer amount exceeds the 1% limit");

            // Check if the recipient's balance would exceed the max wallet limit (only if not excluded)
            uint256 recipientBalanceAfterTransfer = _tOwned[to] + amount;
            require(recipientBalanceAfterTransfer <= maxWalletAmount, "Recipient exceeds maximum wallet balance limit");
        }
        
        bool buy = false;
        bool sell = false;
        bool other = false;
        if (lpPairs[from]) {
            buy = true;
        } else if (lpPairs[to]) {
            sell = true;
        } else {
            other = true;
        }

        // Restrict the buyBackBurnLP wallet transfers to only the DEX pair and DEAD addresses
        if (from == _taxWallets.buyBackBurnLP) {
            require(to == lpPair || to == DEAD, "buyBackBurnLP can only send to DEX pair or burn address");
        }
        
        if (_hasLimits(from, to)) {
            if (!tradingEnabled) {
                if (!other) {
                    revert("Trading not yet enabled!");
                } else if (
                    !_isExcludedFromProtection[from] &&
                    !_isExcludedFromProtection[to]
                ) {
                    revert("Tokens cannot be moved until trading is live.");
                }
            }
        }

        if (sell) {
            if (!inSwap) {
                if (contractSwapEnabled) {
                    uint256 contractTokenBalance = balanceOf(address(this));
                    if (contractTokenBalance >= swapThreshold) {
                        uint256 swapAmt = swapAmount;
                        if (piContractSwapsEnabled) {
                            swapAmt =
                                (balanceOf(lpPair) * piSwapPercent) /
                                masterTaxDivisor;
                        }
                        if (contractTokenBalance >= swapAmt) {
                            contractTokenBalance = swapAmt;
                        }
                        contractSwap(contractTokenBalance);
                    }
                }
            }
        }
        return finalizeTransfer(from, to, amount, buy, sell, other);
    }

    function contractSwap(uint256 contractTokenBalance) internal inSwapFlag {
        Ratios memory ratios = _ratios;
        if (ratios.totalSwap == 0) {
            return;
        }

        if (
            _allowances[address(this)][address(dexRouter)] != type(uint256).max
        ) {
            _allowances[address(this)][address(dexRouter)] = type(uint256).max;
        }

        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = dexRouter.WETH();

        try
            dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
                contractTokenBalance,
                0,
                path,
                address(this),
                block.timestamp
            )
        {} catch {
            return;
        }

        uint256 amtBalance = address(this).balance;
        bool success;
        uint256 developmentBalance = (amtBalance * ratios.development) /
            ratios.totalSwap;
        uint256 externalBuybackBalance = (amtBalance * ratios.buyBackBurnLP) /
            ratios.totalSwap;
        uint256 marketingBalance = amtBalance -
            (developmentBalance + externalBuybackBalance);
        if (ratios.marketing > 0) {
            (success, ) = _taxWallets.marketing.call{
                value: marketingBalance,
                gas: 55000
            }("");
        }
        if (ratios.development > 0) {
            (success, ) = _taxWallets.development.call{
                value: developmentBalance,
                gas: 55000
            }("");
        }
        if (ratios.buyBackBurnLP > 0) {
            (success, ) = _taxWallets.buyBackBurnLP.call{
                value: externalBuybackBalance,
                gas: 55000
            }("");
        }
    }

    function _checkLiquidityAdd(address from, address to) internal {
        require(!_hasLiqBeenAdded, "Liquidity already added and marked.");
        if (!_hasLimits(from, to) && to == lpPair) {
            _liquidityHolders[from] = true;
            _isExcludedFromFees[from] = true;
            _hasLiqBeenAdded = true;
            if (address(initializer) == address(0)) {
                initializer = Initializer(address(this));
            }
            contractSwapEnabled = true;
            emit ContractSwapEnabledUpdated(true);
        }
    }

    function enableTrading() public onlyOwner {
        require(!tradingEnabled, "Trading already enabled!");
        require(_hasLiqBeenAdded, "Liquidity must be added.");
        if (address(initializer) == address(0)) {
            initializer = Initializer(address(this));
        }
        try
            initializer.setLaunch(
                lpPair,
                uint32(block.number),
                uint64(block.timestamp),
                _decimals
            )
        {} catch {}
        try initializer.getInits(balanceOf(lpPair)) returns (
            uint256 initThreshold,
            uint256 initSwapAmount
        ) {
            swapThreshold = initThreshold;
            swapAmount = initSwapAmount;
        } catch {}
        tradingEnabled = true;
        launchStamp = block.timestamp;
    }

    function sweepContingency() external onlyOwner {
        require(!_hasLiqBeenAdded, "Cannot call after liquidity.");
        payable(_owner).transfer(address(this).balance);
    }

    function sweepExternalTokens(address token) external onlyOwner {
        if (_hasLiqBeenAdded) {
            require(token != address(this), "Cannot sweep native tokens.");
        }
        IERC20 TOKEN = IERC20(token);
        TOKEN.transfer(_owner, TOKEN.balanceOf(address(this)));
    }

    function multiSendTokens(
        address[] memory accounts,
        uint256[] memory amounts
    ) external onlyOwner {
        require(accounts.length == amounts.length, "Lengths do not match.");
        for (uint16 i = 0; i < accounts.length; i++) {
            require(
                balanceOf(msg.sender) >= amounts[i] * 10 ** _decimals,
                "Not enough tokens."
            );
            finalizeTransfer(
                msg.sender,
                accounts[i],
                amounts[i] * 10 ** _decimals,
                false,
                false,
                true
            );
        }
    }

    // Calculate the vested amount that can be claimed
    function vestedAndClaimable(address account) public view returns (uint256) {
        Lock memory lock = lockedTokens[account];
        
        if (block.timestamp < lock.releaseTime) {
            return 0;  // Still in lock period
        }
        
        uint256 elapsedTime = block.timestamp - lock.vestingStart;
        
        if (elapsedTime >= lock.vestingDuration) {
            // All tokens are fully vested after the vesting duration
            return lock.totalAmount - lock.claimed;
        }
        
        // Calculate linear vesting amount
        uint256 vested = (lock.totalAmount * elapsedTime) / lock.vestingDuration;
        
        // Return the claimable amount (vested minus already claimed)
        return vested - lock.claimed;
    }

    function finalizeTransfer(
        address from,
        address to,
        uint256 amount,
        bool buy,
        bool sell,
        bool other
    ) internal returns (bool) {

        uint256 availableBalance = _tOwned[from];
        // If the sender has locked tokens, calculate the vested amount
        if (lockedTokens[from].totalAmount > 0) {
            uint256 claimable = vestedAndClaimable(from);
            availableBalance = availableBalance.sub(lockedTokens[from].totalAmount - claimable);
            
            require(amount <= availableBalance, "Amount exceeds unlocked tokens");
            
            // Update the claimed amount in the lock
            lockedTokens[from].claimed = lockedTokens[from].claimed.add(amount);
        }

        bool takeFee = true;
        if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
            takeFee = false;
        }
        _tOwned[from] -= amount;
        uint256 amountReceived = (takeFee)
            ? takeTaxes(from, amount, buy, sell)
            : amount;
        
        _tOwned[to] += amountReceived;
        emit Transfer(from, to, amountReceived);

        if (!_hasLiqBeenAdded) {
            _checkLiquidityAdd(from, to);
            if (
                !_hasLiqBeenAdded &&
                _hasLimits(from, to) &&
                !_isExcludedFromProtection[from] &&
                !_isExcludedFromProtection[to] &&
                !other
            ) {
                revert("Pre-liquidity transfer protection.");
            }
        }
        return true;
    }

    function takeTaxes(
        address from,
        uint256 amount,
        bool buy,
        bool sell
    ) internal returns (uint256) {
        uint256 currentFee = getDynamicTaxRate(buy, sell);

        if (currentFee == 0) {
            return amount;
        }

        uint256 feeAmount = (amount * currentFee) / masterTaxDivisor;
        if (feeAmount > 0) {
            _tOwned[address(this)] += feeAmount;
            emit Transfer(from, address(this), feeAmount);
        }

        return amount - feeAmount;
    }

    function getDynamicTaxRate(bool buy, bool sell) public view returns (uint256) {
        uint256 baseRate;

        if (buy) {
            baseRate = _taxRates.buyFee;
        } else if (sell) {
            baseRate = _taxRates.sellFee;
        } else {
            baseRate = _taxRates.transferFee;
        }

        if (block.timestamp >= launchStamp) {
            uint256 minutesSinceLaunch = (block.timestamp - launchStamp) / 60;
            
            if (minutesSinceLaunch >= maxReductionMinutes) {
                // After 4 minutes, tax is reduced to the final rate of 5%
                return finalTaxRate;  // 5%
            } else {
                // Each minute, reduce tax by 5% starting from 25%
                uint256 reducedRate = initialTaxRate - (minutesSinceLaunch * taxReductionPerMinute); 
                return reducedRate;  // Return the dynamic rate
            }
        }

        return baseRate; // Return the base rate before the launch
    }

    function setMaxTransferAmount(uint256 _maxTransferAmount) external onlyOwner {
        require(_maxTransferAmount > 0, "Max transfer amount must be greater than zero");
        maxTransferAmount = _maxTransferAmount;
    }

    function setMaxWalletAmount(uint256 _maxWalletAmount) external onlyOwner {
        require(_maxWalletAmount > 0, "Max wallet amount must be greater than zero");
        maxWalletAmount = _maxWalletAmount;
    }


}

{
  "compilationTarget": {
    "contracts/NyxCipher.sol": "NyxCipher"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}