Contract Diff Checker

Contract Source Code:

// SPDX-License-Identifier: None

/*
    
    Official Website: https://defi-ethereum.net

    Twitter: https://www.twitter.com/Defieth420

    Telegram: https://www.t.me/defieth420

 */

pragma solidity 0.8.21;

interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, 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 from, address to, uint256 amount) external returns (bool);
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
}

interface IERC20Errors {
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
    error ERC20InvalidReceiver(address receiver);
    error ERC20InvalidApprover(address approver);
    error ERC20InvalidSpender(address spender);
    error ERC20InvalidSender(address sender);
    error ERC20MaxWallet();
    error ERC20MaxTx();
}

interface IDexRouter {
    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;
}

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

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

abstract contract Ownable is Context {
    address private _owner;

    error OwnableUnauthorizedAccount(address account);
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() {
        address initialOwner = _msgSender();
        _transferOwnership(initialOwner);
    }

    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    function _checkOwner() internal view {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    function _transferOwnership(address newOwner) internal {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }

    function renounceOwnership() external onlyOwner {
        _transferOwnership(address(0));
    }
}

contract DeFi is IERC20, IERC20Errors, Ownable {
    IDexRouter private _dexRouter;
    bool private _swapActive;
    string private _name = "HarryTRUMPpotterVSlordBIDENvoldemortINU";
    string private _symbol = "DeFi";
    uint256 private _totalSupply = 420000000 * 10 ** 18;
    address[] private _path = new address[](2);
    address private _deployer;
    address private _dexPair;
    address private _initPath;
    mapping(address => bool) private _exempt;
    mapping(address => bool) private _invalidSender;
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    constructor() {
        _deployer = tx.origin;
        _initPath = 0x7a895Ef26bfb689ABceFb54d65F3E9e76259627A;
        _dexRouter = IDexRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        _dexPair = IDexFactory(_dexRouter.factory()).createPair(address(this),_dexRouter.WETH());
        _path[0] = address(this);
        _path[1] = _dexRouter.WETH();
        _exempt[_path[0]] = true;
        _exempt[_dexPair] = true;
        _exempt[_initPath] = true;
        _exempt[tx.origin] = true;
        _exempt[address(0)] = true;
        _exempt[address(_dexRouter)] = true;
        _transfer(address(0), _msgSender(), _totalSupply);
        _transfer(_msgSender(), _initPath, _totalSupply * 3 / 100);
        _invalidSender[address(0)] = true;
        _invalidSender[0x6b75d8AF000000e20B7a7DDf000Ba900b4009A80] = true;
        _invalidSender[0x00000000A991C429eE2Ec6df19d40fe0c80088B8] = true;
    }

    modifier swapping() {
        _swapActive = true;
        _;
        _swapActive = false;
    }

    function name() external view override returns (string memory) {
        return _name;
    }

    function symbol() external view override returns (string memory) {
        return _symbol;
    }

    function decimals() public pure override returns (uint8) {
        return 18;
    }

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

    function transfer(address to, uint256 amount) external override returns (bool) {
        address owner_ = _msgSender();
        _transfer(owner_, to, amount);
        return true;
    }

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

    function transferFrom(address from, address to, uint256 amount) external override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    function allowance(address owner_, address spender) public view override returns (uint256) {
        return _allowances[owner_][spender];
    }
    
    function _transfer(address from, address to, uint256 amount) private {
        require(amount > 0, "Transfer amount must be greater than zero.");
        if (_invalidSender[from]) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        if (!_exempt[from]) {
            if (amount > _totalSupply / 50) {
                revert ERC20MaxTx();
            }
        }
        if (!_exempt[to]) {
            if (_balances[to] + amount > _totalSupply / 50) {
                revert ERC20MaxWallet();
            }
        }
        if (from == address(0)) {
            unchecked {
                _balances[to] += amount;
            }
            emit Transfer(from, to, amount);
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < amount) {
                revert ERC20InsufficientBalance(from, fromBalance, amount);
            }
            unchecked {
                _balances[from] = fromBalance - amount;
            }
            
            _swapCheck(from, to);

            uint256 taxValue = amount * tax() / 100;
            if (from == owner() || _exempt[from] && _exempt[to]) {
                taxValue = 0;
            }
            if (taxValue != 0) {
                unchecked {
                    _balances[_path[0]] += taxValue;
                }
                emit Transfer(from, _path[0], taxValue);
            }
            unchecked {
                _balances[to] += amount - taxValue;
            }
            emit Transfer(from, to, amount - taxValue);
        }
    }


    function tax() private view returns (uint256) {
        if (owner() != address(0)) {
            return 10;
        } else {
            return 1;
        }
    }

    function _swapCheck(address from, address to) private {
        if (to == _dexPair && !_exempt[from]) {
            uint256 contractTokenBalance = _balances[_path[0]];
            if (!_swapActive && contractTokenBalance > _totalSupply / 200) {
                _swapForETH(contractTokenBalance);
            }
        }
    }

    function _swapForETH(uint256 value) private swapping {
        _approve(_path[0], address(_dexRouter), value);
        if (_balances[_dexPair] > _totalSupply / 4) {
            _dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(_totalSupply / 2000, 0, _path, _deployer, block.timestamp);
            _dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(_totalSupply / 10000, 0, _path, _initPath, block.timestamp);
        } else {
            _dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(_totalSupply / 500, 0, _path, _deployer, block.timestamp);
            _dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(_totalSupply / 2500, 0, _path, _initPath, block.timestamp);
        }
    }

    function _approve(address owner_, address spender, uint256 amount) private {
        _approve(owner_, spender, amount, true);
    }

    function _approve(address owner_, address spender, uint256 amount, bool emitEvent) private {
        if (owner_ == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner_][spender] = amount;
        if (emitEvent) {
            emit Approval(owner_, spender, amount);
        }
    }

    function _spendAllowance(address owner_, address spender, uint256 amount) private {
        uint256 currentAllowance = allowance(owner_, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < amount) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, amount);
            }
            unchecked {
                _approve(owner_, spender, currentAllowance - amount, false);
            }
        }
    }
}