// SPDX-License-Identifier: MIT

pragma solidity ^0.8.9;
interface IXERC20 {
  /**
   * @notice Emits when a lockbox is set
   *
   * @param _lockbox The address of the lockbox
   */

  event LockboxSet(address _lockbox);

  /**
   * @notice Emits when a limit is set
   *
   * @param _mintingLimit The updated minting limit we are setting to the bridge
   * @param _burningLimit The updated burning limit we are setting to the bridge
   * @param _bridge The address of the bridge we are setting the limit too
   */
  event BridgeLimitsSet(uint256 _mintingLimit, uint256 _burningLimit, address indexed _bridge);

  /**
   * @notice Reverts when a user with too low of a limit tries to call mint/burn
   */

  error IXERC20_NotHighEnoughLimits();

  /**
   * @notice Reverts when caller is not the factory
   */

  error IXERC20_NotFactory();

  struct Bridge {
    BridgeParameters minterParams;
    BridgeParameters burnerParams;
  }

  struct BridgeParameters {
    uint256 timestamp;
    uint256 ratePerSecond;
    uint256 maxLimit;
    uint256 currentLimit;
  }

  /**
   * @notice Sets the lockbox address
   *
   * @param _lockbox The address of the lockbox
   */
   

  function setLockbox(address _lockbox) external;

  /**
   * @notice Updates the limits of any bridge
   * @dev Can only be called by the owner
   * @param _mintingLimit The updated minting limit we are setting to the bridge
   * @param _burningLimit The updated burning limit we are setting to the bridge
   * @param _bridge The address of the bridge we are setting the limits too
   */
  function setLimits(address _bridge, uint256 _mintingLimit, uint256 _burningLimit) external;

  /**
   * @notice Returns the max limit of a minter
   *
   * @param _minter The minter we are viewing the limits of
   *  @return _limit The limit the minter has
   */
  function mintingMaxLimitOf(address _minter) external view returns (uint256 _limit);

  /**
   * @notice Returns the max limit of a bridge
   *
   * @param _bridge the bridge we are viewing the limits of
   * @return _limit The limit the bridge has
   */

  function burningMaxLimitOf(address _bridge) external view returns (uint256 _limit);

  /**
   * @notice Returns the current limit of a minter
   *
   * @param _minter The minter we are viewing the limits of
   * @return _limit The limit the minter has
   */

  function mintingCurrentLimitOf(address _minter) external view returns (uint256 _limit);

  /**
   * @notice Returns the current limit of a bridge
   *
   * @param _bridge the bridge we are viewing the limits of
   * @return _limit The limit the bridge has
   */

  function burningCurrentLimitOf(address _bridge) external view returns (uint256 _limit);

  /**
   * @notice Mints tokens for a user
   * @dev Can only be called by a minter
   * @param _user The address of the user who needs tokens minted
   * @param _amount The amount of tokens being minted
   */

  function mint(address _user, uint256 _amount) external;

  /**
   * @notice Burns tokens for a user
   * @dev Can only be called by a minter
   * @param _user The address of the user who needs tokens burned
   * @param _amount The amount of tokens being burned
   */

  function burn(address _user, uint256 _amount) external;
}

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

abstract contract Ownable {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () {
        address msgSender = msg.sender;
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == msg.sender, "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

contract WBurnfolio is IBEP20, Ownable, IXERC20
{
    mapping (address => uint) public  balanceOf;
    mapping (address => mapping (address => uint)) public allowance;
    mapping(address => bool) public excludedFromFees;
    mapping(address => bool) public isAMM;
    mapping(address => bool) public minterRole;
    string private constant _name = "Burnfolio";
    string private constant _symbol = "BF";

    function name() external pure override returns (string memory) {
        return _name;
    }
    function symbol() external pure override returns (string memory) {
        return _symbol;
    }

    uint8 public constant decimals = 9;
    uint public totalSupply=0;
    //Total amount of tokens on other chains
    uint public totalBridged=900_000_000*10**decimals;
    address public constant BurnWallet=address(0xDead);
    address public IncentiveWallet;


    modifier isMinter() {
        require(minterRole[msg.sender], "Not Minter");
        _;
    }
    constructor () {
        excludedFromFees[msg.sender]=true;
        excludedFromFees[address(this)]=true;
        IncentiveWallet=msg.sender;
    }

    function isContract(address _addr) private view returns (bool){
        uint32 size;
        assembly {
        size := extcodesize(_addr)
        }
        return (size > 0);
    }

    //transfer function, every transfer runs through this function
    function _transfer(address sender, address recipient, uint amount) private{
        require(sender != address(0), "Transfer from zero");
        require(recipient != address(0), "Transfer to zero");

        if(excludedFromFees[sender] || excludedFromFees[recipient])
            _feelessTransfer(sender, recipient, amount);
        else{ 
            _taxedTransfer(sender,recipient,amount);                  
        }
    }
    function _taxedTransfer(address sender, address recipient, uint amount) private{
        uint senderBalance = balanceOf[sender];
        require(senderBalance >= amount, "Transfer exceeds balance");
        unchecked{
        uint tax=0;
        if(isAMM[sender])
            tax++;
        if(isAMM[recipient])
            tax++;

        uint taxedAmount=amount*tax/200;
        balanceOf[BurnWallet]+=taxedAmount;
        balanceOf[IncentiveWallet]+=taxedAmount;
        balanceOf[sender]=senderBalance-amount;
        balanceOf[recipient]+=(amount-taxedAmount*2);
        }
        emit Transfer(sender,recipient,amount);
    }


    //Feeless transfer only transfers and autostakes
    function _feelessTransfer(address sender, address recipient, uint amount) private{
        uint senderBalance = balanceOf[sender];
        require(senderBalance >= amount, "Transfer exceeds balance");
        unchecked{
            balanceOf[sender]-=amount;
            balanceOf[recipient]+=amount; 
        }
     
        emit Transfer(sender,recipient,amount);
    }
    
  function mintingMaxLimitOf(address) external view returns (uint256 _limit){
    return totalBridged;
}
  function burningMaxLimitOf(address) external view returns (uint256 _limit){
    return totalSupply;
}

  function mintingCurrentLimitOf(address) external view returns (uint256 _limit){
    return totalBridged;
  }

  function burningCurrentLimitOf(address) external view returns (uint256 _limit){
    return totalSupply;
  }

    address public lockbox;
  function setLockbox(address _lockbox) external onlyOwner{
    lockbox=_lockbox;
    emit LockboxSet(lockbox);
  }

  function setLimits(address _bridge, uint256 _mintingLimit, uint256 _burningLimit) external onlyOwner{

  }
    event OnExcludeAccount(address account, bool exclude);
    //Exclude/Include account from fees (eg. CEX)
    function excludeAccountFromFees(address account, bool exclude) external onlyOwner{
        require(account!=address(this),"can't Include the contract");
        excludedFromFees[account]=exclude;
        emit OnExcludeAccount(account,exclude);
    }
    event OnAddPair(address account);
    function AddPair(address newPair) external{
        require(isContract(newPair));
        require(IBEP20(newPair).balanceOf(msg.sender)>0);
        isAMM[newPair]=true;
        emit OnAddPair(newPair);
    }
    event OnRemovePair(address account,bool flag);
    function RemovePair(address pair,bool flag) external onlyOwner{
        isAMM[pair]=flag;
        emit  OnRemovePair(pair,flag);
    }
    bool public addMinterLocked;
    event OnLockAddingMinters();
    function LockAddingMinters() external onlyOwner{
        addMinterLocked=true;
        emit OnLockAddingMinters();
    }
    event OnSetMinter(address account,bool flag);
    function SetMinter(address minter,bool flag) external onlyOwner{
        require(!flag||!addMinterLocked,"No new minters can be added");
        minterRole[minter]=flag;
        emit OnSetMinter(minter,flag);
    }
    event OnSetIncentiveWallet(address account);
    function SetIncentiveWallet(address _incentiveWallet) external onlyOwner{
        IncentiveWallet=_incentiveWallet;
        emit OnSetIncentiveWallet(_incentiveWallet);
    }

    bool _locked;
    modifier lock{
        require(!_locked);
        _locked=true;
        _;
        _locked=false;
    }
     function mint(address recipient, uint amount)external lock isMinter{
        totalBridged-=amount;
        totalSupply+=amount;
        balanceOf[recipient]+=amount;
        emit Transfer(address(0),recipient,amount);
    }
    function burn(address account, uint amount)external lock isMinter{
        totalBridged+=amount;
        totalSupply-=amount;
        balanceOf[account]-=amount;
        emit Transfer(account,address(0),amount);
    }

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

    function approve(address spender, uint amount) external override returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }
    function _approve(address owner, address spender, uint amount) private {
        require(owner != address(0), "Approve from zero");
        require(spender != address(0), "Approve to zero");

        allowance[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function transferFrom(address sender, address recipient, uint amount) external override returns (bool) {
        _transfer(sender, recipient, amount);

        uint currentAllowance = allowance[sender][msg.sender];
        require(currentAllowance >= amount, "Transfer > allowance");

        _approve(sender, msg.sender, currentAllowance - amount);
        return true;
    }
    function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
        _approve(msg.sender, spender, allowance[msg.sender][spender] + addedValue);
        return true;
    }
        function _decreaseAllowance(address owner,address spender, uint256 subtractedValue) private returns (bool) {
        uint256 currentAllowance = allowance[owner][spender];
        require(currentAllowance >= subtractedValue);

        _approve(owner, spender, currentAllowance - subtractedValue);
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
        uint256 currentAllowance = allowance[msg.sender][spender];
        require(currentAllowance >= subtractedValue);

        _approve(msg.sender, spender, currentAllowance - subtractedValue);
        return true;
    }
}

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