Sycnal (SYCN)

// SPDX-License-Identifier: MIT
/* 
Sycnal is an intelligent trading platform designed to enhance decision-making across digital asset markets.
Our mission is to empower traders and institutions with automation, predictive analytics, and real-time market intelligence.
Telegram : https://t.me/sycnalofficial
Website  : http://sycnal.xyz/
Twitter  : http://x.com/sycnalofficial

*/
pragma solidity ^0.8.23;

// ===== Utilities & Standard Interfaces =====
abstract contract Context {
    function _msgSender() internal view virtual returns (address) { return msg.sender; }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address) external view returns (uint256);
    function transfer(address,uint256) external returns (bool);
    function allowance(address,address) external view returns (uint256);
    function approve(address,uint256) external returns (bool);
    function transferFrom(address,address,uint256) external returns (bool);
    event Transfer(address indexed from,address indexed to,uint256 value);
    event Approval(address indexed owner,address indexed spender,uint256 value);
}

contract Ownable is Context {
    address private _owner;
    event OwnershipTransferred(address indexed previousOwner,address indexed newOwner);
    constructor(){ _owner=_msgSender(); emit OwnershipTransferred(address(0),_owner); }
    function owner() public view returns(address){ return _owner; }
    modifier onlyOwner(){ require(_owner==_msgSender(),"NotOwner"); _; }
    function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner,address(0)); _owner=address(0); }
}

// Router Uniswap V2 (ETH Mainnet)
interface IUniswapV2Factory { function createPair(address tokenA,address tokenB) external returns(address pair); }
interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint,uint,address[] calldata,address,uint) external;
    function factory() external pure returns(address);
    function WETH() external pure returns(address);
    function addLiquidityETH(address,uint,uint,uint,address,uint) external payable returns(uint,uint,uint);
}

contract Sycnal is Context, IERC20, Ownable {
    /* --------------------------------------------------------------------- */
    /*  BASIC TOKEN CONFIG                                                   */
    /* --------------------------------------------------------------------- */
    string  private constant _name    = "Sycnal";
    string  private constant _symbol  = "SYCN";
    uint8   private constant _decimals= 9;
    uint256 private constant _tTotal  = 100_000_000 * 10**_decimals; // 100M supply

    mapping(address=>uint256) private _balances;
    mapping(address=>mapping(address=>uint256)) private _allowances;
    // DEX pair registry and exemptions
    mapping(address=>bool) public marketPair;     // DEX pair addresses
    mapping(address=>bool) private _exempt;       // exempt from wallet limit & transfer tax

    /* --------------------------------------------------------------------- */
    /*  TAX & DYNAMIC LOGIC                                                  */
    /* --------------------------------------------------------------------- */
    uint256 private _firstBuyTax  = 20; // initial buy tax %
    uint256 private _firstSellTax = 20; // initial sell tax %
    uint256 private _finalBuyTax  = 5;  // reduced buy tax %
    uint256 private _finalSellTax = 5;  // reduced sell tax %
    uint256 private _transferTax  = 2;  // transfer (wallet to wallet) tax %
    uint256 private _antiDumpTax  = 10; // extra % for large sells
    uint256 private _antiDumpThreshold = 100_000 * 10**_decimals; // large sell threshold

    uint256 private _reduceBuyTaxAt  = 30; // switch to final buy tax after this many buys
    uint256 private _reduceSellTaxAt = 30; // switch to final sell tax after this many buys
    uint256 private _preventSwapBefore = 10; // minimum buy count before swaps are allowed

    /* --------------------------------------------------------------------- */
    /*  LIMITS & SWAP PARAMETERS                                             */
    /* --------------------------------------------------------------------- */
    uint256 public _maxTxAmount      = 2_000_000 * 10**_decimals; // 2% supply
    uint256 public _maxWalletSize    = 2_000_000 * 10**_decimals; // 2% supply
    uint256 public _taxSwapThreshold = 150_000 * 10**_decimals;   // min tokens to attempt swap
    uint256 public _maxTaxSwap       = 250_000 * 10**_decimals;   // max tokens per swap
    bool    public swapOnBuy = true;   // allow swap trigger on buys
    bool    public caLimit   = true;   // early per-block sell limiter
    uint256 public caBlockLimit = 3;   // sells per block allowed while active

    /* --------------------------------------------------------------------- */
    /*  DYNAMIC STATE                                                        */
    /* --------------------------------------------------------------------- */
    uint256 private _buyCount;        // total buys counted
    uint256 private _sellBlockCount;  // sells in current block (for caLimit)
    uint256 private _lastSellBlock;   // last block a sell happened
    uint256 private _firstBlock;      // block when trading opened
    bool    private tradingOpen;
    bool    private inSwap;
    bool    private swapEnabled;
    bool    public  tokenFinalized;   // config locked after finalize

    // time-based fallback swap
    uint256 public lastSwapTime;
    uint256 public minTimeBetweenSwaps = 300;              // 5 minutes
    uint256 public minTimeSwapBalance  = 50_000 * 10**_decimals; // min tax token balance for time fallback

    // tax wallet only (accounting removed for simplicity & gas)
    address payable private _taxWallet; // recipient of swapped ETH

    // Router
    IUniswapV2Router02 private _router;
    address public uniswapV2Pair;

    /* --------------------------------------------------------------------- */
    /*  EVENT                                                                */
    /* --------------------------------------------------------------------- */
    event AutoSwap(uint256 tokens,uint256 ethOut,bool timeFallback);
    event TokenFinalized(uint256 buy,uint256 sell,uint256 transferTax,uint256 antiDump);
    event TaxPhaseReduced(uint256 newBuy,uint256 newSell,uint256 buyCount);
    event MaxTxAmountUpdated(uint256 maxTx);

    /* --------------------------------------------------------------------- */
    /*  MODIFIER                                                             */
    /* --------------------------------------------------------------------- */
    modifier lockTheSwap { inSwap = true; _; inSwap = false; }
    modifier notFinalized { require(!tokenFinalized, "Finalized"); _; }

    /* --------------------------------------------------------------------- */
    /*  Constructor                                                          */
    /* --------------------------------------------------------------------- */
    constructor(){
        _taxWallet = payable(0x310dBDc25B0544469A9b9f04dd8C3aC3818E274F);
        _balances[msg.sender] = _tTotal;
        _exempt[msg.sender] = true;
        _exempt[address(this)] = true;
        emit Transfer(address(0), msg.sender, _tTotal);
    }

    /* --------------------------------------------------------------------- */
    /*  ERC20 STANDARD                                                       */
    /* --------------------------------------------------------------------- */
    function name() public pure returns(string memory){ return _name; }
    function symbol() public pure returns(string memory){ return _symbol; }
    function decimals() public pure returns(uint8){ return _decimals; }
    function totalSupply() public pure override returns(uint256){ return _tTotal; }
    function balanceOf(address a) public view override returns(uint256){ return _balances[a]; }
    function allowance(address o,address s) public view override returns(uint256){ return _allowances[o][s]; }

    function approve(address s,uint256 a) public override returns(bool){ _approve(_msgSender(), s, a); return true; }
    function transfer(address r,uint256 a) public override returns(bool){ _transfer(_msgSender(), r, a); return true; }
    function transferFrom(address f,address t,uint256 a) public override returns(bool){ _transfer(f, t, a); uint256 al = _allowances[f][_msgSender()]; require(al >= a, "Allowance"); _approve(f,_msgSender(), al - a); return true; }

    function _approve(address o,address s,uint256 a) private { require(o!=address(0)&&s!=address(0),"Zero"); _allowances[o][s]=a; emit Approval(o,s,a); }

    /* --------------------------------------------------------------------- */
    /*  CORE TRANSFER + TAX                                                  */
    /* --------------------------------------------------------------------- */
    function _transfer(address f,address t,uint256 amt) private {
        require(f!=address(0) && t!=address(0) && amt>0, "Invalid");
        uint256 tax;

        if (f!=owner() && t!=owner()) {
            bool isBuy  = marketPair[f];
            bool isSell = marketPair[t];

            if (isBuy) {
                require(amt <= _maxTxAmount && _balances[t] + amt <= _maxWalletSize, "Limit");
                if (_firstBlock + 1 > block.number) require(!_isContract(t), "NoBot");
                tax = amt * (_buyCount > _reduceBuyTaxAt ? _finalBuyTax : _firstBuyTax) / 100;
                _buyCount++;
                if(_buyCount == _reduceBuyTaxAt + 1 && (_finalBuyTax < _firstBuyTax || _finalSellTax < _firstSellTax)) {
                    emit TaxPhaseReduced(_finalBuyTax,_finalSellTax,_buyCount);
                }
            } else if (isSell) {
                uint256 base = _buyCount > _reduceSellTaxAt ? _finalSellTax : _firstSellTax;
                tax = amt * (amt > _antiDumpThreshold ? (base + _antiDumpTax) : base) / 100;
            } else {
                require(_balances[t] + amt <= _maxWalletSize, "WLimit");
                if(!_exempt[t] && !_exempt[f] && !marketPair[f]) tax = amt * _transferTax / 100;
            }

            // Auto swap logic
            // - Normal trigger: on sell or (buy if swapOnBuy), once threshold met & after early buy count
            // - Time fallback: after minTimeBetweenSwaps and minTimeSwapBalance, to avoid stuck taxes in low volume
            uint256 cBal = _balances[address(this)];
            bool isBuyOrSell = isSell || (swapOnBuy && isBuy);
            bool trigNormal = isBuyOrSell && cBal > _taxSwapThreshold && _buyCount > _preventSwapBefore;
            bool trigTime   = (block.timestamp - lastSwapTime >= minTimeBetweenSwaps) && cBal >= minTimeSwapBalance && _buyCount > _preventSwapBefore;

            if ((trigNormal || trigTime) && !inSwap && swapEnabled) {
                // per-block sell limiter (only on normal sell-trigger)
                if (trigNormal && caLimit && isSell) {
                    if (block.number > _lastSellBlock) _sellBlockCount = 0;
                    require(_sellBlockCount < caBlockLimit, "CA Limit");
                    _sellBlockCount++;
                    _lastSellBlock = block.number;
                }
                // swap amount is capped per-tx on normal trigger, or by maxTaxSwap on time fallback
                uint256 swapAmt = trigNormal ? _min(amt, _min(cBal, _maxTaxSwap)) : _min(cBal, _maxTaxSwap);
                uint256 prevBal = address(this).balance;
                _swapTokensForEth(swapAmt);
                uint256 gained = address(this).balance - prevBal;
                if (address(this).balance > 0) _taxWallet.transfer(address(this).balance);
                lastSwapTime = block.timestamp;
                emit AutoSwap(swapAmt, gained, trigTime && !trigNormal);
            }
        }

        if (tax > 0) {
            _balances[address(this)] += tax;
            emit Transfer(f, address(this), tax);
        }
        unchecked { _balances[f] -= amt; }
        _balances[t] += amt - tax;
        emit Transfer(f, t, amt - tax);
    }

    /* --------------------------------------------------------------------- */
    /*  INTERNAL HELPER                                                      */
    /* --------------------------------------------------------------------- */
    function _min(uint256 a,uint256 b) private pure returns(uint256){ return a<b?a:b; }
    function _isContract(address a) private view returns(bool){ uint256 s; assembly { s := extcodesize(a) } return s>0; }
    function _swapTokensForEth(uint256 amount) private lockTheSwap {
        address[] memory path = new address[](2);
        path[0] = address(this); path[1] = _router.WETH();
        _approve(address(this), address(_router), amount);
        _router.swapExactTokensForETHSupportingFeeOnTransferTokens(amount, 0, path, address(this), block.timestamp);
    }

    /* --------------------------------------------------------------------- */
    /*  CONFIG (Before Finalization)                                         */
    /* --------------------------------------------------------------------- */
    function updateSwapSettings(uint256 nb,uint256 ns,uint256 rb,uint256 rs,uint256 prev) external onlyOwner notFinalized {
        require(nb<=25 && ns<=25, "HighTax");
        _firstBuyTax=nb; _firstSellTax=ns; _reduceBuyTaxAt=rb; _reduceSellTaxAt=rs; _preventSwapBefore=prev;
    }
    function updateTransferTax(uint256 nt) external onlyOwner notFinalized { require(nt<=5, "HighTransfer"); _transferTax=nt; }
    function updateAntiDumpSettings(uint256 nA,uint256 nThr) external onlyOwner notFinalized { require(nA<=15, "HighAD"); _antiDumpTax=nA; _antiDumpThreshold=nThr*10**_decimals; }
    function emergencyTaxMode(bool e) external onlyOwner notFinalized {
        if(e){ _firstBuyTax=25; _firstSellTax=25; _finalBuyTax=15; _finalSellTax=15; }
        else { _firstBuyTax=20; _firstSellTax=20; _finalBuyTax=5; _finalSellTax=5; }
    }
    function extendHighTaxPeriod(uint256 nb,uint256 ns) external onlyOwner notFinalized { require(nb<=200 && ns<=200, "TooLong"); _reduceBuyTaxAt=nb; _reduceSellTaxAt=ns; }
    function updateTaxWallet(address payable w) external onlyOwner notFinalized { require(w!=address(0), "Zero"); _taxWallet=w; }
    function openMax() external onlyOwner notFinalized { _maxTxAmount=_tTotal; _maxWalletSize=_tTotal; emit MaxTxAmountUpdated(_tTotal); }
    function setSwapOnBuy(bool v) external onlyOwner notFinalized { swapOnBuy = v; }
    function setTimeSwapConfig(uint256 secondsBetween,uint256 minTokenBalance) external onlyOwner notFinalized {
        require(secondsBetween<=3600, "Interval");
        require(minTokenBalance <= _tTotal/50, "TooHigh");
        minTimeBetweenSwaps = secondsBetween;
        minTimeSwapBalance = minTokenBalance;
    }
    function finalizeToken(bool removeAntiDump,bool zeroTransferTax) external onlyOwner notFinalized {
        _firstBuyTax=_finalBuyTax; _firstSellTax=_finalSellTax;
        if(removeAntiDump) _antiDumpTax=0;
        if(zeroTransferTax) _transferTax=0;
        tokenFinalized = true;
        emit TokenFinalized(_finalBuyTax,_finalSellTax,_transferTax,_antiDumpTax);
    }

    /* --------------------------------------------------------------------- */
    /*  LAUNCH                                                               */
    /* --------------------------------------------------------------------- */
    function openTrading() external onlyOwner {
        require(!tradingOpen, "Opened");
        _router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        _approve(address(this), address(_router), _tTotal);
        uniswapV2Pair = IUniswapV2Factory(_router.factory()).createPair(address(this), _router.WETH());
        marketPair[uniswapV2Pair] = true;
        uint256 liqTokens = 80_000_000 * 10**_decimals;
        require(_balances[address(this)] >= liqTokens, "Need >=80M tokens in contract");
        _router.addLiquidityETH{value: address(this).balance}(
            address(this), liqTokens, 0, 0, owner(), block.timestamp
        );
        IERC20(uniswapV2Pair).approve(address(_router), type(uint).max);
        swapEnabled = true; tradingOpen = true; _firstBlock = block.number; lastSwapTime = block.timestamp;
    }

    /* --------------------------------------------------------------------- */
    /*  VIEW / MONITORING                                                    */
    /* --------------------------------------------------------------------- */
    function getCurrentTaxRates() external view returns(
        uint256 buy,uint256 sell,uint256 transferTax,uint256 antiDump
    ){
        buy  = _buyCount > _reduceBuyTaxAt  ? _finalBuyTax  : _firstBuyTax;
        sell = _buyCount > _reduceSellTaxAt ? _finalSellTax : _firstSellTax;
        transferTax = _transferTax;
        antiDump = _antiDumpTax;
    }
    function getBuyCount() external view returns(uint256){ return _buyCount; }
    function getPendingSwapable() external view returns(uint256){
        uint256 c = _balances[address(this)];
        if(c < _taxSwapThreshold || _buyCount <= _preventSwapBefore) return 0;
        return c > _maxTaxSwap ? _maxTaxSwap : c;
    }

    /* --------------------------------------------------------------------- */
    /*  MAINTENANCE / EMERGENCY                                              */
    /* --------------------------------------------------------------------- */
    function forceSwap() external onlyOwner {
        uint256 bal = _balances[address(this)];
        require(bal > 0, "NoTax");
        _swapTokensForEth(bal);
        if (address(this).balance > 0) {
            (bool s,) = _taxWallet.call{value: address(this).balance}("");
            require(s, "ETH send fail");
        }
    }

    // Rescue any ETH stuck in the contract (no swap)
    function rescueETH(uint256 amount) external onlyOwner {
        require(amount > 0 && amount <= address(this).balance, "NoETH");
        (bool s,) = _taxWallet.call{value: amount}("");
        require(s, "ETH send fail");
    }

    // Convenience: rescue all ETH
    function rescueAllETH() external onlyOwner {
        uint256 bal = address(this).balance;
        require(bal > 0, "NoETH");
        (bool s,) = _taxWallet.call{value: bal}("");
        require(s, "ETH send fail");
    }

    function rescueStuckERC20Tokens(address t,uint a) external onlyOwner { IERC20(t).transfer(_taxWallet,a); }
    

    receive() external payable {}
}