// SPDX-License-Identifier: MIT

pragma solidity ^0.8.23;

// SOCIALS
// Telegram Channel: https://t.me/SkiMask_Pepe
// X https://x.com/SkiMaskPepe_eth
//
//
// ███████╗██╗  ██╗██╗    ███╗   ███╗ █████╗ ███████╗██╗  ██╗    ██████╗ ███████╗██████╗ ███████╗
// ██╔════╝██║ ██╔╝██║    ████╗ ████║██╔══██╗██╔════╝██║ ██╔╝    ██╔══██╗██╔════╝██╔══██╗██╔════╝
// ███████╗█████╔╝ ██║    ██╔████╔██║███████║███████╗█████╔╝     ██████╔╝█████╗  ██████╔╝█████╗
// ╚════██║██╔═██╗ ██║    ██║╚██╔╝██║██╔══██║╚════██║██╔═██╗     ██╔═══╝ ██╔══╝  ██╔═══╝ ██╔══╝
// ███████║██║  ██╗██║    ██║ ╚═╝ ██║██║  ██║███████║██║  ██╗    ██║     ███████╗██║     ███████╗
// ╚══════╝╚═╝  ╚═╝╚═╝    ╚═╝     ╚═╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝    ╚═╝     ╚══════╝╚═╝     ╚══════╝
//
//
//


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;
  address private _previousOwner;
  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);
  }

  function transferOwnership(address newOwner) public virtual onlyOwner {
    require(newOwner != address(0), "Ownable: new owner is the zero address");
    emit OwnershipTransferred(_owner, newOwner);
    _owner = newOwner;
  }

}

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

interface IUniswapV2Factory {
  function createPair(address tokenA, address tokenB)
  external
  returns (address pair);
}

interface IUniswapV2Router02 {
  function swapExactTokensForETHSupportingFeeOnTransferTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external;

  function factory() external pure returns (address);

  function WETH() external pure returns (address);

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

contract SkiMaskPepe is Context, IERC20, Ownable {

  using SafeMath for uint256;

  // Token details
  string private constant _name = "Ski Mask Pepe";
  string private constant _symbol = "SPEPE";
  uint8 private constant _decimals = 18;
  uint256 private constant _tTotal = 1000000000 * 10**9 * 10**9; // 1 000 000 000

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


  // Fees
  uint256 private _feeAutoLP = 15; // Initial percentage
  uint256 private _feeExtraAutoLP = 35; // Initial percentage
  uint256 private _feeMarketing = 10; // Initial percentage
  uint256 private _currentLiquidityFee = _feeAutoLP + _feeExtraAutoLP; // Initial percentage
  uint256 private _currentMarketingFee = _feeMarketing; // Initial percentage

  uint256 private _previousFeeAutoLP;
  uint256 private _previousFeeMarketing;

  // Restrictions
  uint256 public _maxTxAmount = _tTotal.mul(2).div(100); // Initial 2% max tx
  uint256 public _swapTokensAtAmount = 5000000 * 10**9 * 10**9;

  // Addresses
  address payable private _marketingWallet = payable(0x288401d6219F46E4eFD2E610330f2eb79bDb6686);

  // Uniswap V2
  IUniswapV2Router02 public immutable _uniswapV2Router;
  address public uniswapV2Pair;

  // Operative
  bool private inSwap = false;
  bool private swapEnabled = true;
  bool private _tradingEnabled = false;


  event MaxTxAmountUpdated(uint256 _maxTxAmount);

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

  constructor() {

//    _uniswapV2Router = IUniswapV2Router02(0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24);  // Base Mainnet
    _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);  // ETH Mainnet
    uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());

    _approve(address(this), address(_uniswapV2Router), _tTotal);
    IERC20(uniswapV2Pair).approve(address(_uniswapV2Router), type(uint).max);

    _balances[_msgSender()] = _tTotal;
    _isExcludedFromFee[owner()] = true;
    _isExcludedFromFee[address(this)] = true;

    emit Transfer(address(0), _msgSender(), _tTotal);
  }

  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 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) {
    _transfer(sender, recipient, amount);
    _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
    return true;
  }

  function removeAllFee() private {
    if (_currentLiquidityFee == 0 && _currentMarketingFee == 0) return;

    _previousFeeAutoLP = _currentLiquidityFee;
    _previousFeeMarketing = _currentMarketingFee;

    _currentLiquidityFee = 0;
    _currentMarketingFee = 0;
  }

  function restoreAllFee() private {
    _currentLiquidityFee = _previousFeeAutoLP;
    _currentMarketingFee = _previousFeeMarketing;
  }

  function _approve(address owner, address spender, uint256 amount) private {
    require(owner != address(0), "ERC20: approve from the zero address");
    require(spender != address(0), "ERC20: approve to 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), "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");

    if (from != owner() && to != owner()) {
      require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
      require(_tradingEnabled, "TRADING: Not enabled yet");

      uint256 contractTokenBalance = balanceOf(address(this));

      if (swapEnabled && !inSwap && contractTokenBalance >= _swapTokensAtAmount && from != uniswapV2Pair && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {

        uint256 half = _swapTokensAtAmount.div(2);
        uint256 otherHalf = _swapTokensAtAmount.sub(half);

        // swap tokens for ETH
        swapTokensForEth(half);

        // add liquidity to Uniswap
        addLiquidity(otherHalf, address(this).balance);
      }

    }

    bool takeFee = true;

    //Transfer Tokens
    if ((_isExcludedFromFee[from] || _isExcludedFromFee[to])) {
      takeFee = false;
    } else {

      //Set Fee for Buys and Sells
      if (from == uniswapV2Pair || to == uniswapV2Pair) {
        _currentLiquidityFee = _feeAutoLP + _feeExtraAutoLP;
        _currentMarketingFee = _feeMarketing;
        if (_feeExtraAutoLP > 0) _feeExtraAutoLP = _feeExtraAutoLP - 1;
      } else {
        //Remove Fee for Transfers
        takeFee = false;
      }
    }

    _tokenTransfer(from, to, amount, takeFee);
  }

  function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
    if (!takeFee) removeAllFee(); // In case is excluded from the Fee
    _transferStandard(sender, recipient, amount);
    if (!takeFee) restoreAllFee(); // Restore the Fee
  }

  function _transferStandard(address sender, address recipient, uint256 amount) private {

    uint256 taxedForLiquidity = amount.mul(_currentLiquidityFee).div(100);
    uint256 taxedForMarketing = amount.mul(_currentMarketingFee).div(100);

    if(taxedForLiquidity > 0) {
      _balances[address(this)] = _balances[address(this)].add(taxedForLiquidity);
      emit Transfer(sender, address(this), taxedForLiquidity);
    }

    if(taxedForMarketing > 0) {
      _balances[_marketingWallet] = _balances[_marketingWallet].add(taxedForMarketing);
      emit Transfer(sender, _marketingWallet, taxedForMarketing);
    }

    uint256 amountAfterTaxes = amount.sub(taxedForLiquidity).sub(taxedForMarketing);

    _balances[sender] = _balances[sender].sub(amount);
    _balances[recipient] = _balances[recipient].add(amountAfterTaxes);
    emit Transfer(sender, recipient, amountAfterTaxes);
  }


  function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
    // generate the uniswap pair path of token -> weth
    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 addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {

    // approve token transfer to cover all possible scenarios
    _approve(address(this), address(_uniswapV2Router), tokenAmount);

    // add the liquidity
    _uniswapV2Router.addLiquidityETH{value: ethAmount}(
      address(this),
      tokenAmount,
      0, // slippage is unavoidable
      0, // slippage is unavoidable
      owner(),
      block.timestamp
    );
  }

  function boarding() public onlyOwner {
    // Phase two of launch
    _tradingEnabled = true;
  }


  function heating(bool liquify) public onlyOwner {
    // Phase two of launch

    _feeAutoLP = 5;
    _feeMarketing = 5;
    _feeExtraAutoLP = 0;

    if (liquify) {
      uint256 contractTokenBalance = balanceOf(address(this));
      if (contractTokenBalance > 1) {
        uint256 half = contractTokenBalance.div(2);
        uint256 otherHalf = contractTokenBalance.sub(half);

        // swap tokens for ETH
        swapTokensForEth(half);

        // add liquidity to Uniswap
        addLiquidity(otherHalf, address(this).balance);
      }
    }

    _maxTxAmount = _tTotal;
    emit MaxTxAmountUpdated(_maxTxAmount);
  }


  function ignition(bool liquify) public onlyOwner {
    // Phase three (and final) of launch

    _feeAutoLP = 0;
    _feeMarketing = 3;

    // We add any spare tokens to the LP before renouncing ownership
    if (liquify) {
      uint256 contractTokenBalance = balanceOf(address(this));
      if (contractTokenBalance > 1) {
        uint256 half = contractTokenBalance.div(2);
        uint256 otherHalf = contractTokenBalance.sub(half);

        // swap tokens for ETH
        swapTokensForEth(half);

        // add liquidity to Uniswap
        addLiquidity(otherHalf, address(this).balance);
      }
    }
    swapEnabled = false;
    renounceOwnership();
  }

  receive() external payable {}



// .------..------..------.
// |A.--. ||S.--. ||P.--. |
// | (\/) || :/\: || :/\: |
// | :\/: || :\/: || (__) |
// | '--'A|| '--'S|| '--'P|
// `------'`------'`------'

}

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