// SPDX-License-Identifier: MIT

/*

# Sky Raiders

Enter a world transformed by a cosmic event, where the past of humankind is a distant story.
The 2040 meteor impact birthed a world of clouds and floating islands.
This marks the dawn of the Skyward Isles, a place where the sky is the ultimate adventure.
You, a Sky Raider, crash back to Earth in 3169, surviving against all odds to find yourself on a deserted outpost, accompanied by a jet-pack.
Your journey in the celestial realms begins here.
But remember, the vast sky is just the beginning of what lies beyond.

# Craft, Combat, Conquer

Begin your adventure in a massive open-world, third-person universe, where creativity meets adventure.
From a simple outpost, build your stronghold by crafting, looting, and building.
Navigate through mysterious skies—either solo or with friends—engaging foes in both PvP and PvE zones.
Participate in events and tournaments for rewards or become a seasoned merchant by trading on the marketplace,
where you can buy or sell items with $SKY tokens between other players.

# Links

Play Online: https://skyraiders.app
Docs: https://docs.skyraiders.app
Telegram: https://t.me/skyraiders_game
YouTube:  https://www.youtube.com/@skyraiders_game
X: https://x.com/skyraiders_game

*/

pragma solidity 0.8.24;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);

    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
    );
}

contract Ownable is Context {
    address private _owner;
    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

    constructor() {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    function owner() public view returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }
}

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 swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    )
        external
        payable
        returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}

interface IArbitrumBridge {
    function bridgeTokens(uint256 amount) external;

    function unbridgeTokens(address recipient, uint256 amount) external;

    function setL2ContractAddress(address _l2ContractAddress) external;
}

contract SKY is Context, IERC20, Ownable, IArbitrumBridge {
    string private constant _name = "Sky Raiders";
    string private constant _symbol = "SKY";
    uint8 private constant _decimals = 18;
    uint256 private constant _totalSupply = 100_000_000 * 10 ** _decimals;

    uint256 public _maxTransactionAmount = 800_000 * 10 ** _decimals;
    uint256 public _maxWalletSize = 800_000 * 10 ** _decimals;

    uint256 public _taxTrigger = 100_000 * 10 ** _decimals;
    uint256 public _taxThreshold = 100_000 * 10 ** _decimals;
    uint256 public _taxMaxSwap = 1_000_000 * 10 ** _decimals;

    uint256 private constant _initialBuyTax = 40;
    uint256 private constant _initialSellTax = 40;
    uint256 private constant _reduceTaxAtBuys = 40;
    uint256 private _totalBuyTransactions = 0;

    uint256 public _buyTax = 5;
    uint256 public _sellTax = 5;

    uint256 private _accumulatedTax;
    uint256 private constant _preventTaxSwapBefore = 40;

    bool private didLaunch = false;
    bool private tradingEnabled = false;
    bool private swapEnabled = false;
    bool private inSwap = false;
    bool public liquifyEnabled = false;

    address payable private _marketingWallet;
    address payable private _gameWallet;
    address payable private _deployerWallet;

    mapping(address => bool) private _isExcludedFromFee;
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    address private uniswapV2Pair;
    IUniswapV2Router02 private uniswapV2Router;

    event LaunchExecuted(uint256 tokenAmount, uint256 ethAmount, uint256 timestamp);
    event TradingEnabled(bool _tradingEnabled, bool _swapEnabled);
    event LimitsLifted(uint256 _value);
    event LiquidityAdded(uint256 tokenAmount, uint256 ethAmount);
    event SetTax(uint256 _valueBuy, uint256 _valueSell);
    event SetTaxParameters(uint256 taxTrigger, uint256 taxThreshold);

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

    /**
     * @dev Bridges tokens from L1 to L2 for Sky Raiders, boosting transaction speed and reducing costs.
     * This supports our move towards a partly decentralized Sky Raiders universe where players can own,
     * trade, or sell their game assets like characters, crafted items and skins on the blockchain. Designed for quick
     * and cheap in-game actions, it’s ideal for managing assets in Sky Raiders' marketplace.
     */

    address private l2ContractAddress;
    mapping(address => uint256) private _bridgedTokens;

    event L2AddressSet(address indexed l2ContractAddress);
    event TokensBridged(address indexed user, uint256 amount);
    event TokensUnbridged(address indexed recipient, uint256 amount);

    function setL2ContractAddress(
        address _l2ContractAddress
    ) external onlyOwner {
        require(_l2ContractAddress != address(0), "Invalid contract address");
        l2ContractAddress = _l2ContractAddress;
        emit L2AddressSet(_l2ContractAddress);
    }

    function bridgeTokens(uint256 amount) external {
        require(
            amount <= _balances[msg.sender],
            "Insufficient balance to bridge"
        );
        _bridgedTokens[msg.sender] += amount;
        _balances[msg.sender] -= amount;

        emit TokensBridged(msg.sender, amount);
    }

    function unbridgeTokens(
        address recipient,
        uint256 amount
    ) external onlyOwner lockTheSwap {
        require(
            _bridgedTokens[recipient] >= amount,
            "Unlock amount exceeds bridged balance"
        );
        _transfer(address(this), recipient, amount);
        _bridgedTokens[recipient] -= amount;
        emit TokensUnbridged(recipient, amount);
    }

    constructor() {
        _marketingWallet = payable(0x4ac258D5e923bCA959eAa9D75725260d9C368F85);
        _gameWallet = payable(0x4af267D55a676024A7d4A967dF153cfE62Da600a);
        _deployerWallet = payable(0x3B311AA18C7ECBcA957f36cA018b8a4B407E5B55);

        _isExcludedFromFee[owner()] = true;
        _isExcludedFromFee[_marketingWallet] = true;
        _isExcludedFromFee[_gameWallet] = true;
        _isExcludedFromFee[_deployerWallet] = true;
        _isExcludedFromFee[address(this)] = true;

        setInitialSupply(address(this), (_totalSupply * 80) / 100);
        setInitialSupply(_msgSender(), (_totalSupply * 20) / 100);

    }

    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 _totalSupply;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

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

    function allowance(
        address owner,
        address spender
    ) public view override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(
        address spender,
        uint256 amount
    ) public override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");
        require(
            _allowances[sender][_msgSender()] >= amount,
            "ERC20: transfer amount exceeds allowance"
        );
        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(
            currentAllowance >= amount,
            "ERC20: transfer amount exceeds allowance"
        );
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), currentAllowance - amount);
        return true;
    }

    function _approve(address owner, address spender, uint256 amount) private {
        require(
            owner != address(0) && spender != address(0),
            "ERC20: approve the zero address"
        );
        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _transfer(address from, address to, uint256 amount) private {
        require(
            from != address(0) && to != address(0),
            "ERC20: transfer the zero address"
        );
        require(amount > 0, "Transfer amount must be greater than zero");
        uint256 taxAmount = 0;
        uint256 finalAmount = amount;
        if (from != owner() && to != owner()) {
            if (!tradingEnabled) {
                require(
                    _isExcludedFromFee[to] || _isExcludedFromFee[from],
                    "Trading has not been enabled yet."
                );
            }

            bool isBuy = from == uniswapV2Pair && to != address(this);
            bool isSell = to == uniswapV2Pair && from != address(this);

            if (isSell) {
                uint256 taxRate = (_totalBuyTransactions > _reduceTaxAtBuys)
                    ? _sellTax
                    : _initialSellTax;
                taxAmount = (amount * taxRate) / 100;
                finalAmount = amount - taxAmount;
            } else if (isBuy) {
                uint256 taxRate = (_totalBuyTransactions > _reduceTaxAtBuys)
                    ? _buyTax
                    : _initialBuyTax;
                taxAmount = (amount * taxRate) / 100;
                finalAmount = amount - taxAmount;
            }

            if (
                from == uniswapV2Pair &&
                to != address(uniswapV2Router) &&
                !_isExcludedFromFee[to]
            ) {
                require(
                    finalAmount <= _maxTransactionAmount,
                    "Transaction amount exceeds the maximum allowed limit"
                );
                require(
                    balanceOf(to) + finalAmount <= _maxWalletSize,
                    "Recipient's wallet balance will exceed the maximum allowed limit"
                );
                _totalBuyTransactions++;
            }

            _accumulatedTax += taxAmount;
            uint256 tokenBalance = balanceOf(address(this));

            if (
                !inSwap &&
                to == uniswapV2Pair &&
                swapEnabled &&
                tokenBalance > _taxThreshold &&
                _totalBuyTransactions > _preventTaxSwapBefore &&
                _accumulatedTax > _taxTrigger
            ) {
                uint256 getMinValue = (tokenBalance > _taxMaxSwap)
                    ? _taxMaxSwap
                    : tokenBalance;
                swapTokensForEth((amount > getMinValue) ? getMinValue : amount);
                uint256 contractETHBalance = address(this).balance;
                if (contractETHBalance > 0) {
                    distributeFees(contractETHBalance);
                }
                _accumulatedTax = 0;
            }
        }

        if (taxAmount > 0) {
            _balances[address(this)] += taxAmount;

            emit Transfer(from, address(this), taxAmount);
        }
        _balances[from] -= finalAmount;
        _balances[to] += (finalAmount);
        emit Transfer(from, to, finalAmount);
    }

    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        uniswapV2Router.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0,
            0,
            owner(),
            block.timestamp
        );
        emit LiquidityAdded(tokenAmount, ethAmount);
    }

    function toggleAddLiquidity() external onlyOwner {
        liquifyEnabled = !liquifyEnabled;
    }

    function distributeFees(uint256 amount) private lockTheSwap {
        uint256 half = amount / 2;
        _gameWallet.transfer(half);

        if (liquifyEnabled) {
            uint256 totalTokens = balanceOf(address(this));
            addLiquidity(totalTokens, half);
        } else {
            _marketingWallet.transfer(half);
        }
    }

    function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            address(this),
            block.timestamp
        );
    }

    function setInitialSupply(address account, uint256 amount) private {
        require(account != address(0), "ERC20: mint to the zero address");
        _balances[account] = amount;
        emit Transfer(address(0), account, amount);
    }

    function launch() external onlyOwner {
        require(!didLaunch, "Launch already called");
        require(
            address(this).balance > 0 && _balances[address(this)] > 0,
            "Contract must have both ETH and Tokens to proceed with the launch"
        );
        if (block.chainid == 1) {
            uniswapV2Router = IUniswapV2Router02(
                0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
            );
        } else if (block.chainid == 11155111) {
            uniswapV2Router = IUniswapV2Router02(
                0x86dcd3293C53Cf8EFd7303B57beb2a3F671dDE98
            );
        } else {
            revert("Unsupported chain ID");
        }

        _approve(
            address(this),
            address(uniswapV2Router),
            _balances[address(this)]
        );
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(
                address(this),
                uniswapV2Router.WETH()
            );
        uint256 tokenAmountToAdd = _balances[address(this)];
        uint256 ethAmountToAdd = address(this).balance;
        addLiquidity(tokenAmountToAdd, ethAmountToAdd);
        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
        didLaunch = true;
    }

    function start() external onlyOwner {
        require(!tradingEnabled, "Trading already opened");
        swapEnabled = true;
        tradingEnabled = true;
        emit TradingEnabled(tradingEnabled, swapEnabled);
    }

    function liftLimits() external onlyOwner {
        _maxTransactionAmount = _totalSupply;
        _maxWalletSize = _totalSupply;
        emit LimitsLifted(_totalSupply);
    }

    function setTax(uint256 _valueBuy, uint256 _valueSell) external onlyOwner {
        require(
            _valueBuy <= 12 && _valueSell <= 12 && tradingEnabled,
            "Exceeds value"
        );
        _buyTax = _valueBuy;
        _sellTax = _valueSell;
        emit SetTax(_valueBuy, _valueSell);
    }

    function setTaxParameters(
        uint256 taxTrigger,
        uint256 taxThreshold
    ) external onlyOwner {
        require(tradingEnabled, "Trading is not enabled");
        // You can add more validation as needed
        _taxTrigger = taxTrigger * 10 ** _decimals;
        _taxThreshold = taxThreshold * 10 ** _decimals;
        emit SetTaxParameters(taxTrigger, taxThreshold);
    }

    function withdrawStuckTax() external onlyOwner {
        uint256 taxAmount = _accumulatedTax;
        require(taxAmount > 0, "No tax to withdraw");
        uint256 tokenBalance = balanceOf(address(this));
        require(tokenBalance >= taxAmount, "Insufficient tokens in contract");
        _transfer(address(this), _gameWallet, taxAmount);
        _accumulatedTax = 0;
    }

    function withdrawStuckEther(uint256 amount) external onlyOwner {
        require(tradingEnabled, "Trading must be enabled");
        require(didLaunch, "Liquidity must be added");
        require(amount <= address(this).balance, "Insufficient balance");
        payable(owner()).transfer(amount);
    }

    function withdrawStuckTokens(
        address tokenAddress,
        uint256 amount
    ) external onlyOwner {
        require(tradingEnabled, "Trading must be enabled");
        require(didLaunch, "Liquidity must be added");
        require(
            tokenAddress != address(this),
            "The contract's native tokens remain locked for security purposes"
        );
        IERC20 tokenContract = IERC20(tokenAddress);
        uint256 contractBalance = tokenContract.balanceOf(address(this));
        require(amount <= contractBalance, "Insufficient balance");
        tokenContract.transfer(owner(), amount);
    }

    receive() external payable {}
}

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