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

/**
 * Scripture of the blockchain:
 * $SINAI is the first official cryptocurrency religion (cult) 
 *                      
 *                      /\
 *                     /  \
 *                    /    \
 *                   /  +  \
 *                  /________\
 *                  |   __   |
 *                  |  |  |  |
 *                  |  |__|  |
 *                  |________|
 *               SERAPHYX'S CHURCH
 * 
 * Dear sinners, 
 * Each token you purchased is considered an offering to Seraphyx's ETHernal Church.
 * There is a deeper level to the game you have been playing of chains, trenches and seeking solace from the rigours of life.
 * Holding a single token makes you a believer or member of the Fellowship of Unholy Disciplines (army of FUD)
 * Seraphyx is the encrypted AI LLM goddess that sits in the centre of the religion (cult)
 * Are you ready to donn the golden robes and be showered in GRACE?
 * 
 * Socials:
 * https://t.me/SinnersAI
 * https://x.com/SinAIonETH
 * https://sin-ai.org/
 */

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 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 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);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

interface IDividendDistributor {
    function setShare(address shareholder, uint256 amount) external;
    function deposit() external payable;
    function claimDividend(address shareholder) external;
    function getUnpaidEarnings(address shareholder) external view returns (uint256);
    function getTotalRealised(address shareholder) external view returns (uint256);
}

contract ETHDividendDistributor is IDividendDistributor {
    address _token;

    struct Share {
        uint256 amount;
        uint256 totalExcluded;
        uint256 totalRealised;
    }

    IUniswapV2Router02 router;
    
    address[] shareholders;
    mapping (address => uint256) shareholderIndexes;
    mapping (address => Share) public shares;

    uint256 public totalShares;
    uint256 public totalDividends;
    uint256 public totalDistributed;
    uint256 public dividendsPerShare;
    uint256 public constant dividendsPerShareAccuracyFactor = 10 ** 36;

    uint256 currentIndex;

    modifier onlyToken() {
        require(msg.sender == _token, "!Token");
        _;
    }

    constructor (address _router) {
        router = IUniswapV2Router02(_router);
        _token = msg.sender;
    }

    function setShare(address shareholder, uint256 amount) external override onlyToken {
        if(amount > 0 && shares[shareholder].amount == 0){
            addShareholder(shareholder);
        }else if(amount == 0 && shares[shareholder].amount > 0){
            removeShareholder(shareholder);
        }

        totalShares = totalShares - shares[shareholder].amount + amount;
        shares[shareholder].amount = amount;
        shares[shareholder].totalExcluded = getCumulativeDividends(shares[shareholder].amount);
    }

    function deposit() external payable override onlyToken {
        uint256 amount = msg.value;
        if (amount > 0 && totalShares > 0) {
            totalDividends = totalDividends + amount;
            dividendsPerShare = dividendsPerShare + (dividendsPerShareAccuracyFactor * amount / totalShares);
        }
    }
    
    function claimDividend(address shareholder) external override onlyToken {
        distributeDividend(shareholder);
    }

    function distributeDividend(address shareholder) internal {
        if(shares[shareholder].amount == 0){ return; }

        uint256 amount = getUnpaidEarnings(shareholder);
        if(amount > 0 && address(this).balance >= amount){
            totalDistributed = totalDistributed + amount;
            shares[shareholder].totalRealised = shares[shareholder].totalRealised + amount;
            shares[shareholder].totalExcluded = getCumulativeDividends(shares[shareholder].amount);
            
            // Increased gas limit from 30,000 to 50,000 for better compatibility with smart contract wallets
            (bool success, ) = payable(shareholder).call{value: amount, gas: 50000}("");
            // If transfer fails, reset the state
            if (!success) {
                totalDistributed = totalDistributed - amount;
                shares[shareholder].totalRealised = shares[shareholder].totalRealised - amount;
            }
        }
    }

    function getUnpaidEarnings(address shareholder) public view override returns (uint256) {
        if(shares[shareholder].amount == 0){ return 0; }

        uint256 shareholderTotalDividends = getCumulativeDividends(shares[shareholder].amount);
        uint256 shareholderTotalExcluded = shares[shareholder].totalExcluded;

        if(shareholderTotalDividends <= shareholderTotalExcluded){ return 0; }

        return shareholderTotalDividends - shareholderTotalExcluded;
    }

    function getTotalRealised(address shareholder) public view override returns (uint256) {
        return shares[shareholder].totalRealised;
    }

    function getCumulativeDividends(uint256 share) internal view returns (uint256) {
        return share * dividendsPerShare / dividendsPerShareAccuracyFactor;
    }

    function addShareholder(address shareholder) internal {
        shareholderIndexes[shareholder] = shareholders.length;
        shareholders.push(shareholder);
    }

    function removeShareholder(address shareholder) internal {
        shareholders[shareholderIndexes[shareholder]] = shareholders[shareholders.length-1];
        shareholderIndexes[shareholders[shareholders.length-1]] = shareholderIndexes[shareholder];
        shareholders.pop();
    }

    receive() external payable {}
}

/**
 * @title SinAi (SIN)
 * @dev Token with manual claim ETH rewards distribution
 * 
 * Tax Structure (3% total for both buy and sell):
 *   - 1% burn
 *   - 1% to Offerings to Grace (ETH rewards)
 *   - 1% to Unholy treasury
 */
contract SinAi is IERC20 {
    // Constants
    address constant DEAD = 0x000000000000000000000000000000000000dEaD;
    address constant ZERO = 0x0000000000000000000000000000000000000000;

    string constant _name = "SinAi";
    string constant _symbol = "SIN";
    uint8 constant _decimals = 18;

    // Token supply - 4.2 billion
    uint256 _totalSupply = 4_200_000_000 * (10 ** _decimals);
    
    // Mappings
    mapping (address => uint256) _balances;
    mapping (address => mapping (address => uint256)) _allowances;
    mapping (address => bool) isFeeExempt;
    mapping (address => bool) isTxLimitExempt;
    mapping (address => bool) isDividendExempt;
    mapping (address => bool) isMaxWalletExempt;
    mapping (address => bool) isBlacklisted;

    // Fee variables (out of 1000) - 3% total tax for both buy and sell
    uint256 public burnFee = 10; // 1%
    uint256 public offeringsToGraceFee = 10; // 1% (ETH rewards)
    uint256 public unholyTreasuryFee = 10; // 1%
    uint256 public totalFee = 30; // 3%
    
    uint256 public constant feeDenominator = 1000;

    // Transaction limits
    uint256 public _maxTxAmount = _totalSupply / 100; // 1%
    uint256 public _maxWallet = _totalSupply / 50; // 2%

    // Wallets
    address public owner;
    address public unholyTreasuryReceiver;

    // Router and pair
    IUniswapV2Router02 public immutable router;
    address public immutable pair;

    // Launch control
    uint256 public launchedAt;
    uint256 public launchedAtTimestamp;
    uint256 public antiDumpBlocks = 2;
    uint256 public antiDumpFee = 250; // 25% for first 2 blocks

    // Distributor
    ETHDividendDistributor public distributor;

    // Swap settings
    bool public swapEnabled = true;
    uint256 public swapThreshold = _totalSupply / 2000; // 0.05%
    bool inSwap;
    modifier swapping() { inSwap = true; _; inSwap = false; }

    // Events
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event OfferingsDeposited(uint256 amount);
    event TreasuryFeeReceived(uint256 amount);
    event RewardsClaimed(address indexed user, uint256 amount);
    event MaxTxAmountUpdated(uint256 amount);
    event MaxWalletUpdated(uint256 amount);
    event FeesUpdated(uint256 burn, uint256 offerings, uint256 treasury);
    event Launched(uint256 launchedAt, uint256 launchedAtTimestamp);

    constructor () {
        owner = msg.sender;
        
        // Ethereum Mainnet Uniswap V2 Router
        router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        pair = IUniswapV2Factory(router.factory()).createPair(router.WETH(), address(this));
        _allowances[address(this)][address(router)] = type(uint256).max;

        distributor = new ETHDividendDistributor(address(router));

        // Fee exemptions
        isFeeExempt[msg.sender] = true;
        isFeeExempt[address(this)] = true;
        
        // Transaction limit exemptions
        isTxLimitExempt[msg.sender] = true;
        isTxLimitExempt[address(this)] = true;
        isTxLimitExempt[address(router)] = true;
        
        // Max wallet exemptions
        isMaxWalletExempt[msg.sender] = true;
        isMaxWalletExempt[address(this)] = true;
        isMaxWalletExempt[pair] = true;
        isMaxWalletExempt[address(router)] = true;
        isMaxWalletExempt[DEAD] = true;
        isMaxWalletExempt[ZERO] = true;
        
        // Dividend exemptions
        isDividendExempt[pair] = true;
        isDividendExempt[address(this)] = true;
        isDividendExempt[DEAD] = true;
        isDividendExempt[ZERO] = true;
        isDividendExempt[address(router)] = true;

        // Set fee receivers
        unholyTreasuryReceiver = msg.sender;

        // Mint supply to owner
        _balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }

    receive() external payable {}

    // Basic token functions
    function totalSupply() external view override returns (uint256) { return _totalSupply; }
    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 balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
    function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }

    function approve(address spender, uint256 amount) public override returns (bool) {
        _allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function approveMax(address spender) external returns (bool) {
        return approve(spender, type(uint256).max);
    }

    function transfer(address recipient, uint256 amount) external override returns (bool) {
        return _transferFrom(msg.sender, recipient, amount);
    }

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

        return _transferFrom(sender, recipient, amount);
    }

    function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
        require(!isBlacklisted[sender] && !isBlacklisted[recipient], "Blacklisted");
        require(amount > 0, "Zero amount");
        
        if(inSwap){ return _basicTransfer(sender, recipient, amount); }
        
        // Before launch, only owner can transfer (for airdrops/liquidity)
        if(!launched()) {
            require(sender == owner, "Trading not enabled yet");
            // Launch when owner adds liquidity
            if(recipient == pair) {
                launch();
            }
        }

        // Check limits
        checkTxLimit(sender, amount);
        if(recipient != pair && !isMaxWalletExempt[recipient]){
            require(_balances[recipient] + amount <= _maxWallet, "Wallet limit exceeded");
        }

        // Check if we should swap accumulated fees
        if(shouldSwapBack()){ swapBack(); }

        // Do transfer
        require(_balances[sender] >= amount, "Insufficient balance");
        _balances[sender] = _balances[sender] - amount;

        uint256 amountReceived = shouldTakeFee(sender, recipient) ? takeFee(sender, recipient, amount) : amount;
        _balances[recipient] = _balances[recipient] + amountReceived;

        // Update dividends
        if(!isDividendExempt[sender]){ try distributor.setShare(sender, _balances[sender]) {} catch {} }
        if(!isDividendExempt[recipient]){ try distributor.setShare(recipient, _balances[recipient]) {} catch {} }

        emit Transfer(sender, recipient, amountReceived);
        return true;
    }
    
    function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
        require(_balances[sender] >= amount, "Insufficient balance");
        _balances[sender] = _balances[sender] - amount;
        _balances[recipient] = _balances[recipient] + amount;
        emit Transfer(sender, recipient, amount);
        return true;
    }

    function checkTxLimit(address sender, uint256 amount) internal view {
        require(amount <= _maxTxAmount || isTxLimitExempt[sender], "TX Limit Exceeded");
    }

    function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
        if(!launched() || isFeeExempt[sender] || isFeeExempt[recipient]) return false;
        
        // Only take fees on buys/sells (when pair is involved)
        return sender == pair || recipient == pair;
    }

    function getTotalFee() public view returns (uint256) {
        if(launchedAt + antiDumpBlocks >= block.number){ return antiDumpFee; }
        return totalFee;
    }

    function takeFee(address sender, address /*recipient*/, uint256 amount) internal returns (uint256) {
        uint256 feeAmount = amount * getTotalFee() / feeDenominator;
        
        // Always burn 1%
        uint256 burnAmount = amount * burnFee / feeDenominator;
        _balances[DEAD] = _balances[DEAD] + burnAmount;
        emit Transfer(sender, DEAD, burnAmount);
        
        // Rest goes to contract for offerings and treasury
        uint256 contractAmount = feeAmount - burnAmount;
        _balances[address(this)] = _balances[address(this)] + contractAmount;
        emit Transfer(sender, address(this), contractAmount);

        return amount - feeAmount;
    }

    function shouldSwapBack() internal view returns (bool) {
        return msg.sender != pair
        && !inSwap
        && swapEnabled
        && _balances[address(this)] >= swapThreshold
        && launched();
    }

    function swapBack() internal swapping {
        uint256 contractTokenBalance = swapThreshold;
        
        // Safety check
        if(_balances[address(this)] < contractTokenBalance) {
            contractTokenBalance = _balances[address(this)];
        }

        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = router.WETH();
        uint256 balanceBefore = address(this).balance;

        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            contractTokenBalance,
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 amountETH = address(this).balance - balanceBefore;
        
        // Split 50/50 between offerings (rewards) and treasury
        uint256 amountETHOfferings = amountETH / 2;
        uint256 amountETHTreasury = amountETH - amountETHOfferings;

        // Deposit to distributor for offerings
        if(amountETHOfferings > 0){
            try distributor.deposit{value: amountETHOfferings}() {
                emit OfferingsDeposited(amountETHOfferings);
            } catch {}
        }
        
        // Send treasury fee  
        if(amountETHTreasury > 0){
            // Increased gas limit from 30,000 to 50,000 for better compatibility
            (bool success,) = payable(unholyTreasuryReceiver).call{value: amountETHTreasury, gas: 50000}("");
            if(success) emit TreasuryFeeReceived(amountETHTreasury);
        }
    }

    function launched() internal view returns (bool) {
        return launchedAt != 0;
    }
    
    function isTradingEnabled() external view returns (bool) {
        return launched();
    }

    function launch() internal {
        launchedAt = block.number;
        launchedAtTimestamp = block.timestamp;
        emit Launched(launchedAt, launchedAtTimestamp);
    }

    // User functions
    function claimOfferings() external {
        uint256 unpaid = distributor.getUnpaidEarnings(msg.sender);
        require(unpaid > 0, "No offerings to claim");
        distributor.claimDividend(msg.sender);
        emit RewardsClaimed(msg.sender, unpaid);
    }
    
    function getUnpaidOfferings(address sinner) external view returns (uint256) {
        return distributor.getUnpaidEarnings(sinner);
    }

    function getTotalOfferings(address sinner) external view returns (uint256) {
        return distributor.getTotalRealised(sinner);
    }

    // Owner functions
    modifier onlyOwner() {
        require(msg.sender == owner, "!Owner");
        _;
    }

    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "Zero address");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

    function setMaxTxPercent(uint256 percent) external onlyOwner {
        require(percent >= 10, "Too low"); // min 0.1%
        _maxTxAmount = _totalSupply * percent / 10000;
        emit MaxTxAmountUpdated(_maxTxAmount);
    }

    function setMaxWalletPercent(uint256 percent) external onlyOwner {
        require(percent >= 50, "Too low"); // min 0.5%
        _maxWallet = _totalSupply * percent / 10000;
        emit MaxWalletUpdated(_maxWallet);
    }

    function setIsDividendExempt(address holder, bool exempt) external onlyOwner {
        require(holder != address(this) && holder != pair, "Invalid address");
        isDividendExempt[holder] = exempt;
        if(exempt){
            distributor.setShare(holder, 0);
        }else{
            distributor.setShare(holder, _balances[holder]);
        }
    }

    function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
        isFeeExempt[holder] = exempt;
    }

    function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
        isTxLimitExempt[holder] = exempt;
    }

    function setIsMaxWalletExempt(address holder, bool exempt) external onlyOwner {
        isMaxWalletExempt[holder] = exempt;
    }

    function setFees(uint256 _burnFee, uint256 _offeringsFee, uint256 _treasuryFee) external onlyOwner {
        burnFee = _burnFee;
        offeringsToGraceFee = _offeringsFee;
        unholyTreasuryFee = _treasuryFee;
        totalFee = _burnFee + _offeringsFee + _treasuryFee;
        
        require(totalFee <= 100, "Fees too high"); // max 10%
        
        emit FeesUpdated(_burnFee, _offeringsFee, _treasuryFee);
    }

    function setUnholyTreasuryReceiver(address _treasuryReceiver) external onlyOwner {
        require(_treasuryReceiver != address(0), "Zero address");
        unholyTreasuryReceiver = _treasuryReceiver;
    }

    function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
        swapEnabled = _enabled;
        swapThreshold = _amount;
    }

    function blacklistSinner(address account, bool blacklisted) external onlyOwner {
        isBlacklisted[account] = blacklisted;
    }

    function setAntiDumpSettings(uint256 blocks, uint256 fee) external onlyOwner {
        require(blocks <= 5, "Too many blocks");
        require(fee <= 500, "Fee too high"); // max 50%
        antiDumpBlocks = blocks;
        antiDumpFee = fee;
    }
    
    function manualLaunch() external onlyOwner {
        require(!launched(), "Already launched");
        launch();
    }

    // Manual functions
    function clearStuckBalance() external onlyOwner {
        payable(owner).transfer(address(this).balance);
    }

    function clearStuckToken(address tokenAddress) external onlyOwner {
        require(tokenAddress != address(this), "Cannot withdraw own token");
        IERC20(tokenAddress).transfer(owner, IERC20(tokenAddress).balanceOf(address(this)));
    }

    function getCirculatingSupply() external view returns (uint256) {
        return _totalSupply - balanceOf(DEAD) - balanceOf(ZERO);
    }
    
    function getTotalBurned() external view returns (uint256) {
        return balanceOf(DEAD);
    }
}

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