contract BooBankerResearchAssociation is ERC20BurnableMaxSupply("BooBanker Research Association", "BBRA"), ERC20Burnable, Ownable, Administrable, ERC20Payable {
    using SafeMath for uint256;

    // uniswap info
    address public uniswapV2Router;
    address public uniswapV2Pair;
    address public uniswapV2Factory;

    // the amount burned tokens every transfer, i.e. 255 = 0.4%, 100 = 1%, 50 = 2%, 40 = 2.5%
    uint256 public burnDivisor;
    // the amount tokens saved for liquidity lock every transfer, i.e. 255 = 0.4%, 100 = 1%, 50 = 2%, 40 = 2.5%
    uint256 public liquidityDivisor;

    // If any token should be minted from burned $bbra (not $brra)
    ISecondaryToken public burnToken;

    // Dynamic burn regulator (less burn with a certain number of nfts etc)
    IProtocolAdapter public protocolAdapter;

    // Whether the protocol should reward those that spend their gas fees locking liquidity
    bool public rewardLiquidityLockCaller;

    // Pause trading after listing until x block - can only be used once
    bool public canPause;
    uint256 public pauseUntilBlock;

    // Timestamp of last liquidity lock call
    uint256 public lastLiquidityLock;

    // 1% of all transfers are sent to marketing fund
    address public _devaddr;

    // Events
    event LiquidityLock(uint256 tokenAmount, uint256 ethAmount);
    event LiquidityBurn(uint256 lpTokenAmount);
    event CallerReward(address caller, uint256 tokenAmount);
    event BuyBack(uint256 ethAmount, uint256 tokenAmount);
    event ProtocolAdapterChange(address _newProtocol);

    constructor(uint256 _burnDivisor, uint256 _liquidityDivisor) public {

        burnDivisor = _burnDivisor;
        liquidityDivisor = _liquidityDivisor;
        _devaddr = msg.sender;
        rewardLiquidityLockCaller = true;
        canPause = true;
        // initial quantity, 13k tokens
        _mint(msg.sender, 13e21);
    }

    function transferFrom(address sender, address recipient, uint256 amount) public checkRunning virtual override returns (bool) {
        uint256 onePct = amount.div(100);
        uint256 liquidityAmount = amount.div(liquidityDivisor);
        // Use dynamic burn divisor if Adapter contract is set
        uint256 burnAmount = amount.div(
            ( address(protocolAdapter) != address(0)
                ? protocolAdapter.getBurnDivisor(pickHuman(sender, recipient), burnDivisor)
                : burnDivisor
            )
        );

        _burn(sender, burnAmount);

        // Should a secondary token be given to recipient from burn amount?
        //
        if(address(burnToken) != address(0)) {
            burnToken.mint(recipient, burnAmount);
        }

        super.transferFrom(sender, _devaddr, onePct);
        super.transferFrom(sender, address(this), liquidityAmount);
        return super.transferFrom(sender, recipient, amount.sub(burnAmount).sub(liquidityAmount).sub(onePct));
    }

    function transfer(address recipient, uint256 amount) public checkRunning virtual override returns (bool) {
        uint256 onePct = amount.div(100);
        uint256 liquidityAmount = amount.div(liquidityDivisor);
        // Use dynamic burn divisor if Adapter contract is set
        uint256 burnAmount = amount.div(
            ( address(protocolAdapter) != address(0)
                ? protocolAdapter.getBurnDivisor(pickHuman(msg.sender, recipient), burnDivisor)
                : burnDivisor
            )
        );

        // do nft adapter
        _burn(msg.sender, burnAmount);

        // Should a secondary token be given to recipient from burn amount?
        if(address(burnToken) != address(0)) {
            burnToken.mint(recipient, burnAmount);
        }

        super.transfer(_devaddr, onePct);
        super.transfer(address(this), liquidityAmount);
        return super.transfer(recipient, amount.sub(burnAmount).sub(liquidityAmount).sub(onePct));
    }

    // Check if _from is human when calculating ProtocolAdapter settings (like burn)
    // so that if you're buying from Uniswap the adjusted burn still works
    function pickHuman(address _from, address _to) public view returns (address) {
        uint256 _codeLength;
        assembly {_codeLength := extcodesize(_from)}
        return _codeLength == 0 ? _from : _to;
    }

    /**
     * @dev Throws if called by any account other than the admin or owner.
     */
    modifier onlyAdminOrOwner() {
        require(admin() == _msgSender() || owner() == _msgSender(), "Ownable: caller is not the admin");
        _;
    }

    // To be used to stop trading at listing - prevent bots from buying
    modifier checkRunning(){
        require(block.number > pauseUntilBlock, "Go away bot");
        _;
    }

    // Trading can only be paused once, ever. Setting pauseUntilBlock to 0 resumes trading after pausing.
    function setPauseUntilBlock(uint256 _pauseUntilBlock) public onlyAdminOrOwner {
        require(canPause || _pauseUntilBlock == 0, 'Pause has already been used once. If disabling pause set block to 0');
        pauseUntilBlock = _pauseUntilBlock;
        // after the first pause we can no longer pause the protocol
        canPause = false;
    }

    /**
     * @dev prevents contracts from interacting with functions that have this modifier
     */
    modifier isHuman() {
        address _addr = msg.sender;
        uint256 _codeLength;

        assembly {_codeLength := extcodesize(_addr)}

//        if (_codeLength == 0) {
//            // use assert to consume all of the bots gas, kek
//            assert(true == false, 'oh boy - bots get rekt');
//        }
        require(_codeLength == 0, "sorry humans only");
        _;
    }

    // Sell half of burned tokens, provides liquidity and locks it away forever
    // can only be called when balance is > 1 and last lock is more than 2 hours ago
    function lockLiquidity() public isHuman() {
        // bbra balance
        uint256 _bal = balanceOf(address(this));
        require(uniswapV2Pair != address(0), "UniswapV2Pair not set in contract yet");
        require(uniswapV2Router != address(0), "UniswapV2Router not set in contract yet");
        require(_bal >= 1e18, "Minimum of 1 BBRA before we can lock liquidity");
        require(balanceOf(msg.sender) >= 5e18, "You must own at least 5 BBra to call lock");

        // caller rewards
        uint256 _callerReward = 0;
        if (rewardLiquidityLockCaller) {
            // subtract caller fee - 2% always
            _callerReward = _bal.div(50);
            _bal = _bal.sub(_callerReward);
        }

        // calculate ratios of bbra-eth for lp
        uint256 bbraToEth = _bal.div(2);
        uint256 brraForLiq = _bal.sub(bbraToEth);

        // Eth Balance before swap
        uint256 startingBalance = address(this).balance;
        swapTokensForWeth(bbraToEth);

        // due to price movements after selling it is likely that less than the amount of
        // eth received will be used for locking
        // instead of making the left over eth locked away forever we can call buyAndBurn() to buy back Bbra with leftover Eth
        uint256 ethFromBbra = address(this).balance.sub(startingBalance);
        addLiquidity(brraForLiq, ethFromBbra);

        emit LiquidityLock(brraForLiq, ethFromBbra);

        // only reward caller after trade to prevent any possible reentrancy
        // check balance is still available
        if (_callerReward != 0) {
            // in case LP takes more tokens than we are expecting reward _callerReward or balanceOf(this) - whichever is smallest
            if(balanceOf(address(this)) >= _callerReward) {
                transfer(msg.sender, _callerReward);
            } else {
                transfer(msg.sender, balanceOf(address(this)));
            }
        }

        lastLiquidityLock = block.timestamp;
    }

    // If for some reason we get more eth than expect from uniswap at time of locking liquidity
    // we buy and burn whatever amount of Bbra we get
    // can optout of burn so that instead it's added to the next liquidity lock instead

    // NOTE: Buy back not working due to address(this) being the token that we're buying from uniswap - apparently they
    // don't accept that. Leaving the code here however for anyone that wishes to adapt it and "fix" it
//    function buyAndBurn(bool _burnTokens) public {
//        // check minimum amount
//        uint256 startingBbra = balanceOf(address(this));
//        uint256 startingEth = address(this).balance;
//
//        require(startingEth >= 5e16, 'Contract balance must be at least 0.05 eth before invoking buyAndBurn');
//
//        swapWethForTokens(address(this).balance);
//        uint256 buyBackAmount = startingBbra.sub(balanceOf(address(this)));
//
//        // if burn is active and we have bought some tokens back successfuly then burnnnn
//        // if burn == false then tokens purchased will be used in liquidity at next lockLiquidity() call
//        if(_burnTokens && buyBackAmount != 0) {
//            // burn whatever amount was bought
//            _burn(address(this), buyBackAmount);
//        }
//        emit BuyBack(startingEth.sub(address(this).balance), buyBackAmount);
//    }
//
//    // buys bbra with left over eth - only called by liquidity lock function or buy&burn function
//    function swapWethForTokens(uint256 ethAmount) internal {
//        address[] memory uniswapPairPath = new address[](2);
//        uniswapPairPath[0] = IUniswapV2Router02(uniswapV2Router).WETH();
//        uniswapPairPath[1] = address(this);
//
//        IUniswapV2Router02(uniswapV2Router)
//        .swapExactETHForTokensSupportingFeeOnTransferTokens{
//        value: ethAmount
//        }(
//            0,
//            uniswapPairPath,
//            address(this),
//            block.timestamp
//        );
//    }

    // swaps bra for eth - only called by liquidity lock function
    function swapTokensForWeth(uint256 tokenAmount) internal {
        address[] memory uniswapPairPath = new address[](2);
        uniswapPairPath[0] = address(this);
        uniswapPairPath[1] = IUniswapV2Router02(uniswapV2Router).WETH();

        _approve(address(this), uniswapV2Router, tokenAmount);

        IUniswapV2Router02(uniswapV2Router)
        .swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            uniswapPairPath,
            address(this),
            block.timestamp
        );
    }

    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
        // approve uniswapV2Router to transfer Brra
        _approve(address(this), uniswapV2Router, tokenAmount);

        // provide liquidity
        IUniswapV2Router02(uniswapV2Router)
        .addLiquidityETH{
            value: ethAmount
        }(
            address(this),
            tokenAmount,
            0,
            0,
            address(this),
            block.timestamp
        );

        // check LP balance
        uint256 _lpBalance = IERC20(uniswapV2Pair).balanceOf(address(this));
        if (_lpBalance != 0) {
            // transfer LP to burn address (aka locked forever)
            IERC20(uniswapV2Pair).transfer(address(0), _lpBalance);
            // any left over eth is sent to marketing for buy backs - will be a very minimal amount
            payable(_devaddr).transfer(address(this).balance);
            emit LiquidityBurn(_lpBalance);
        }
    }

    // returns amount of LP locked permanently
    function lockedLpAmount() public view returns(uint256) {
        if (uniswapV2Pair == address(0)) {
            return 0;
        }

        return IERC20(uniswapV2Pair).balanceOf(address(0));
    }

    // Whether Bbra should reward the person that pays for the gas calling the liquidity lock
    function setRewardLiquidityLockCaller(bool _rewardLiquidityLockCaller) public onlyAdminOrOwner {
        rewardLiquidityLockCaller = _rewardLiquidityLockCaller;
    }

    // Updates secondary token that could be minted from burned supply of BBRA (like BOOB mints ECTO on burn)
    function setSecondaryBurnToken(ISecondaryToken _token) public onlyAdminOrOwner {
        // this prevents the secondary token being itself and therefore negating burn
        require(address(_token) != address(this), 'Secondary token cannot be itself');
        // can be anything else, 0x0 disables secondary token usage
        burnToken = _token;
    }

    // Sets contract that regulates dynamic burn rates (changeable by DAO)
    function setProtocolAdapter(IProtocolAdapter _contract) public onlyAdminOrOwner {
        // setting to 0x0 disabled dynamic burn and is defaulted to regular burn
        protocolAdapter = _contract;
        emit ProtocolAdapterChange(address(_contract));
    }

    // self explanatory
    function setBurnRate(uint256 _burnDivisor) public onlyAdminOrOwner {
        require(_burnDivisor != 0, "Boo: burnDivisor must be bigger than 0");
        burnDivisor = _burnDivisor;
    }

    // self explanatory
    function setLiquidityDivisor(uint256 _liquidityDivisor) public onlyAdminOrOwner {
        require(_liquidityDivisor != 0, "Boo: _liquidityDivisor must be bigger than 0");
        liquidityDivisor = _liquidityDivisor;
    }

    /// @dev Creates `_amount` token to `_to`. Must only be called by the owner (MrBanker), used to mint farming rewards
    // and nothing else
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
        _moveDelegates(address(0), _delegates[_to], _amount);
    }

    // Sets marketing address (where 1% is deposited)
    // Only owner can modify this (MrBanker)
    function setDevAddr(address _dev) public onlyOwner {
        _devaddr = _dev;
    }

    // sets uniswap router and LP pair addresses (needed for buy-back/sell and liquidity lock)
    function setUniswapAddresses(address _uniswapV2Factory, address _uniswapV2Router) public onlyAdminOrOwner {
        require(_uniswapV2Factory != address(0) && _uniswapV2Router != address(0), 'Uniswap addresses cannot be empty');
        uniswapV2Factory = _uniswapV2Factory;
        uniswapV2Router = _uniswapV2Router;

        if (uniswapV2Pair == address(0)) {
            createUniswapPair();
        }
    }

    // create LP pair if one hasn't been created
    // can be public, doesn't matter who calls it
    function createUniswapPair() public {
        require(uniswapV2Pair == address(0), "Pair has already been created");
        require(uniswapV2Factory != address(0) && uniswapV2Router != address(0), "Uniswap addresses have not been set");

        uniswapV2Pair = IUniswapV2Factory(uniswapV2Factory).createPair(
                IUniswapV2Router02(uniswapV2Router).WETH(),
                address(this)
        );
    }

    // Copied and modified from YAM code:
    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
    // Which is copied and modified from COMPOUND:
    // https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol

    /// @dev A record of each accounts delegate
    mapping (address => address) internal _delegates;

    /// @dev A checkpoint for marking number of votes from a given block
    struct Checkpoint {
        uint32 fromBlock;
        uint256 votes;
    }

    /// @dev A record of votes checkpoints for each account, by index
    mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;

    /// @dev The number of checkpoints for each account
    mapping (address => uint32) public numCheckpoints;

    /// @dev The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

    /// @dev The EIP-712 typehash for the delegation struct used by the contract
    bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");

    /// @dev A record of states for signing / validating signatures
    mapping (address => uint) public nonces;

    /// @dev An event thats emitted when an account changes its delegate
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /// @dev An event thats emitted when a delegate account's vote balance changes
    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);

    /**
     * @dev Delegate votes from `msg.sender` to `delegatee`
     * @param delegator The address to get delegatee for
     */
    function delegates(address delegator)
    external
    view
    returns (address)
    {
        return _delegates[delegator];
    }

    /**
     * @dev Delegate votes from `msg.sender` to `delegatee`
     * @param delegatee The address to delegate votes to
     */
    function delegate(address delegatee) external {
        return _delegate(msg.sender, delegatee);
    }

    /**
     * @dev Delegates votes from signatory to `delegatee`
     * @param delegatee The address to delegate votes to
     * @param nonce The contract state required to match the signature
     * @param expiry The time at which to expire the signature
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function delegateBySig(
        address delegatee,
        uint nonce,
        uint expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    )
    external
    {
        bytes32 domainSeparator = keccak256(
            abi.encode(
                DOMAIN_TYPEHASH,
                keccak256(bytes(name())),
                getChainId(),
                address(this)
            )
        );

        bytes32 structHash = keccak256(
            abi.encode(
                DELEGATION_TYPEHASH,
                delegatee,
                nonce,
                expiry
            )
        );

        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                domainSeparator,
                structHash
            )
        );

        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "BOOB::delegateBySig: invalid signature");
        require(nonce == nonces[signatory]++, "BOOB::delegateBySig: invalid nonce");
        require(now <= expiry, "BOOB::delegateBySig: signature expired");
        return _delegate(signatory, delegatee);
    }

    /**
     * @dev Gets the current votes balance for `account`
     * @param account The address to get votes balance
     * @return The number of current votes for `account`
     */
    function getCurrentVotes(address account)
    external
    view
    returns (uint256)
    {
        uint32 nCheckpoints = numCheckpoints[account];
        return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
    }

    /**
     * @dev Determine the prior number of votes for an account as of a block number
     * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
     * @param account The address of the account to check
     * @param blockNumber The block number to get the vote balance at
     * @return The number of votes the account had as of the given block
     */
    function getPriorVotes(address account, uint blockNumber)
    external
    view
    returns (uint256)
    {
        require(blockNumber < block.number, "BOOB::getPriorVotes: not yet determined");

        uint32 nCheckpoints = numCheckpoints[account];
        if (nCheckpoints == 0) {
            return 0;
        }

        // First check most recent balance
        if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
            return checkpoints[account][nCheckpoints - 1].votes;
        }

        // Next check implicit zero balance
        if (checkpoints[account][0].fromBlock > blockNumber) {
            return 0;
        }

        uint32 lower = 0;
        uint32 upper = nCheckpoints - 1;
        while (upper > lower) {
            uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
            Checkpoint memory cp = checkpoints[account][center];
            if (cp.fromBlock == blockNumber) {
                return cp.votes;
            } else if (cp.fromBlock < blockNumber) {
                lower = center;
            } else {
                upper = center - 1;
            }
        }
        return checkpoints[account][lower].votes;
    }

    function _delegate(address delegator, address delegatee)
    internal
    {
        address currentDelegate = _delegates[delegator];
        uint256 delegatorBalance = balanceOf(delegator); // balance of underlying BOOBs (not scaled);
        _delegates[delegator] = delegatee;

        emit DelegateChanged(delegator, currentDelegate, delegatee);

        _moveDelegates(currentDelegate, delegatee, delegatorBalance);
    }

    function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
        if (srcRep != dstRep && amount > 0) {
            if (srcRep != address(0)) {
                // decrease old representative
                uint32 srcRepNum = numCheckpoints[srcRep];
                uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
                uint256 srcRepNew = srcRepOld.sub(amount);
                _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
            }

            if (dstRep != address(0)) {
                // increase new representative
                uint32 dstRepNum = numCheckpoints[dstRep];
                uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
                uint256 dstRepNew = dstRepOld.add(amount);
                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
            }
        }
    }

    function _writeCheckpoint(
        address delegatee,
        uint32 nCheckpoints,
        uint256 oldVotes,
        uint256 newVotes
    )
    internal
    {
        uint32 blockNumber = safe32(block.number, "BOOB::_writeCheckpoint: block number exceeds 32 bits");

        if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
            checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
        } else {
            checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
            numCheckpoints[delegatee] = nCheckpoints + 1;
        }

        emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
    }

    function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
        require(n < 2**32, errorMessage);
        return uint32(n);
    }

    function getChainId() internal pure returns (uint) {
        uint256 chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
}
// 
// Boo with Governance.
// Ownership given to Farming contract and Adminship can be given to DAO contract
function createUniswapPair() public {
        require(uniswapV2Pair == address(0), "Pair has already been created");
        require(uniswapV2Factory != address(0) && uniswapV2Router != address(0), "Uniswap addresses have not been set");

        uniswapV2Pair = IUniswapV2Factory(uniswapV2Factory).createPair(
                IUniswapV2Router02(uniswapV2Router).WETH(),
                address(this)
        );
    }
// create LP pair if one hasn't been created
// can be public, doesn't matter who calls it