Forkchoice Ethereum Mainnet

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

/**
 * @title DappDegens Token (DGN)
 *
 * 📌 Social Media:
 * ────────────────────────────────────────────
 * 🌐 Website:    https://DappDegens.com
 * 📢 Telegram:   https://t.me/DappDegens
 * Ⅹ Twitter/X:   https://twitter.com/DappDegens
 * ────────────────────────────────────────────
 *
 * 🚀 Built by Degens, for Degens.
 */

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

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

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) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

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

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

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

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}
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 value) external returns (bool);

    function allowance(
        address owner,
        address spender
    ) external view returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);
}

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

interface IERC20Errors {
    error ERC20InsufficientBalance(
        address sender,
        uint256 balance,
        uint256 needed
    );

    error ERC20InvalidSender(address sender);

    error ERC20InvalidReceiver(address receiver);

    error ERC20InsufficientAllowance(
        address spender,
        uint256 allowance,
        uint256 needed
    );

    error ERC20InvalidApprover(address approver);

    error ERC20InvalidSpender(address spender);
}

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

contract DappDegens is Ownable, IERC20, IERC20Metadata, IERC20Errors {
    error AlreadyItIs();
    error AmountZero();

    mapping(address => bool) private _isExcludedFromFee;
    mapping(address => bool) private _isLiquidityPool;
    TaxCollector private taxDetails;

    struct TaxCollector {
        uint256 buyTax;
        uint256 sellTax;
        address payable collector;
    }

    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256))
        private _allowances;

    uint256 private _totalSupply;

    uint256 private _taxSwapThreshold = 0;

    string private _name = unicode"DAPP DEGENS";
    string private _symbol = unicode"DGN";

    bool private swapping;
    bool private inSwap = false;
    bool private swapEnabled = true;
    bool public tradingOpen = false;
    IUniswapV2Router02 private uniswapV2Router;

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

    constructor() Ownable(msg.sender) {
        _totalSupply = 100000000000000 * 10 ** 18;
        _balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);

        _isExcludedFromFee[msg.sender] = true;
        _isExcludedFromFee[address(this)] = true;
    }


    function name() public view virtual returns (string memory) {
        return _name;
    }

    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

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

    function getIsLiquidityPool(address _pool) public view returns (bool) {
        return _isLiquidityPool[_pool];
    }

    function getTaxDetails() public view returns (TaxCollector memory) {
        return taxDetails;
    }

    function getTaxBalance() public view returns (uint256) {
        return balanceOf(address(this)) / 10**18;
        }

    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

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

    function approve(
        address spender,
        uint256 value
    ) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    function openTrading() external onlyOwner {
        require(!tradingOpen, "Trading already open");
        tradingOpen = true;
    }

    function manualSwap(uint256 amount) public onlyOwner {
        uint256 tokenBalance = balanceOf(address(this));
        if (amount > 0 && amount <= tokenBalance) {
            swapTokensForEth(amount); // Uses amount
        } else {
            revert AmountZero();
        }

        uint256 cBa = address(this).balance;
        if (cBa > 0) {
            taxDetails.collector.transfer(cBa);
        }
    }

    function Withdraw(
        address _token,
        address to,
        uint256 eAmount,
        uint256 tAmount
    ) public onlyOwner {
        uint256 cBa = address(this).balance;
        if (cBa >= eAmount) {
            payable(to).transfer(eAmount);
        }
        if (
            _token != address(0) &&
            IERC20(_token).balanceOf(address(this)) >= tAmount * 10**18 // Convert input to correct decimal format
        ) {
            IERC20(_token).transfer(to, tAmount * 10**18);
        }
    }


    receive() external payable {}

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    event SwapAttempted(uint256 contractBalance, uint256 swapAmount);

    function _transfer(address from, address to, uint256 value) internal {
    if (from == address(0)) {
        revert ERC20InvalidSender(address(0));
    }
    if (to == address(0)) {
        revert ERC20InvalidReceiver(address(0));
    }

    if (!tradingOpen) {
        require(_isExcludedFromFee[from] || _isExcludedFromFee[to], "Trading is not open yet");
    }

    bool isContractSwap = from == address(this) || to == address(this);
    bool takeFee = !isContractSwap && !(_isExcludedFromFee[from] && _isExcludedFromFee[to]);

    uint256 taxAmount = 0;
    uint256 transferAmount = value;

    if (takeFee) {
        if (_isLiquidityPool[to]) {
            uint256 tB = taxDetails.sellTax;
            if (tB > 0) {
                taxAmount = (value * tB) / 1000;
            }
        } else if (_isLiquidityPool[from]) {
            uint256 tS = taxDetails.buyTax;
            if (tS > 0) {
                taxAmount = (value * tS) / 1000;
            }
        } else {
            takeFee = false;
        }

        if (takeFee && taxAmount > 0) {
            transferAmount = value - taxAmount;
            _update(from, address(this), taxAmount);
            uint256 contractTokenBalance = balanceOf(address(this)); // Check after tax
            bool canSwap = contractTokenBalance >= _taxSwapThreshold && _isLiquidityPool[to] && swapEnabled && !swapping;

            if (canSwap) {
                swapping = true;
                uint256 swapAmount = contractTokenBalance / 2;
                if (swapAmount > contractTokenBalance) {
                    swapAmount = contractTokenBalance;
                }
                swapTokensForEth(swapAmount);
                emit SwapAttempted(contractTokenBalance, swapAmount);
                swapping = false;
            }
        }

        uint256 cBa = address(this).balance;
        if (cBa > 0) {
            taxDetails.collector.transfer(cBa);
        }
    }

    _update(from, to, transferAmount);
}

    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 * 2);
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            address(this),
            block.timestamp + 5 minutes
        );
    }

    function _update(address from, address to, uint256 value) internal virtual {
    if (from != address(0)) {
        uint256 fromBalance = _balances[from];
        if (fromBalance < value) {
            revert ERC20InsufficientBalance(from, fromBalance, value);
        }
        unchecked {
            _balances[from] = fromBalance - value;
        }
    }

    if (to != address(0)) {
        unchecked {
            _balances[to] += value;
        }
    }

    emit Transfer(from, to, value);
}

    function _burn(address, uint256) internal pure {
        revert("Burning is disabled");
    }


    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    function _approve(
        address owner,
        address spender,
        uint256 value,
        bool emitEvent
    ) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    function _spendAllowance(
        address owner,
        address spender,
        uint256 value
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(
                    spender,
                    currentAllowance,
                    value
                );
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }

    function setFeeExemptionStatus(
        address account,
        bool isExempt
    ) public onlyOwner {
        _isExcludedFromFee[account] = isExempt;
    }

    function setAsLiquidityPool(
        address _address,
        bool _status
    ) public onlyOwner {
        if (_isLiquidityPool[_address] == _status) {
            revert AlreadyItIs();
        }
        _isLiquidityPool[_address] = _status;
    }

    function updateTSThreshold(uint256 _newTST) public onlyOwner {
    _taxSwapThreshold = _newTST;
    }

    function AutoSwapEnabled() public onlyOwner {
        swapEnabled = !swapEnabled;
    }

    function AutoSwapStatus() public view returns (bool) {
        return swapEnabled;
    }

    function setRouter(address _router) public onlyOwner {
        uniswapV2Router = IUniswapV2Router02(_router);
    }

    uint256 internal constant MAX_BUY_TAX = 10;
    uint256 internal constant MAX_SELL_TAX = 10;

    function setTaxDetails(
        uint256 _buyTax,
        uint256 _sellTax,
        address _collector
    ) public onlyOwner {
        require(_buyTax <= MAX_BUY_TAX, "Buy tax exceeds max limit");
        require(_sellTax <= MAX_SELL_TAX, "Sell tax exceeds max limit");

        taxDetails.buyTax = _buyTax;
        taxDetails.sellTax = _sellTax;
        taxDetails.collector = payable(_collector);
    }
}