Unable to remove liquidity from pancakeswap

Smart Contracts
1

Hello ,

I added liquidity, trading started, everything went smoothly, fees were correct and autoSwap worked properly to claim BNB for marketing wallet. Now people are no longer holding/trading, so I want to remove liquidity.

The Problem:
When I try to remove liquidity on pancakeswap, upon clicking "Enable" and then "Remove", nothing happens.

When clicking Remove, in the developer console I get:

image
image875×213 30.2 KB

What I've tried:
I have tried clicking "receive WBNB instead". No effect.
I have tried setting liquidity slippage to 49% before removing. No effect.
I have tried removing a small amount of liquidity.

Contract

pragma solidity ^0.7.4;

library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");

    return c;
}

function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    return sub(a, b, "SafeMath: subtraction overflow");
}

function sub(
    uint256 a,
    uint256 b,
    string memory errorMessage
) internal pure returns (uint256) {
    require(b <= a, errorMessage);
    uint256 c = a - b;

    return c;
}

function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
        return 0;
    }

    uint256 c = a * b;
    require(c / a == b, "SafeMath: multiplication overflow");

    return c;
}

function div(uint256 a, uint256 b) internal pure returns (uint256) {
    return div(a, b, "SafeMath: division by zero");
}

function div(
    uint256 a,
    uint256 b,
    string memory errorMessage
) internal pure returns (uint256) {
    require(b > 0, errorMessage);
    uint256 c = a / b;

    return c;
}

function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b != 0);
    return a % b;
}

}

interface IERC20 {
function totalSupply() external view returns (uint256);

function balanceOf(address who) external view returns (uint256);

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

function transfer(address to, uint256 value) external returns (bool);

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

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

event Transfer(address indexed from, address indexed to, uint256 value);

event Approval(
    address indexed owner,
    address indexed spender,
    uint256 value
);

}

interface InterfaceLP {
function sync() external;
}

abstract contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;

constructor(
    string memory name,
    string memory symbol,
    uint8 decimals
) {
    _name = name;
    _symbol = symbol;
    _decimals = decimals;
}

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

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

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

}

library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);

function mul(int256 a, int256 b) internal pure returns (int256) {
    int256 c = a * b;

    require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
    require((b == 0) || (c / b == a));
    return c;
}

function div(int256 a, int256 b) internal pure returns (int256) {
    require(b != -1 || a != MIN_INT256);

    return a / b;
}

function sub(int256 a, int256 b) internal pure returns (int256) {
    int256 c = a - b;
    require((b >= 0 && c <= a) || (b < 0 && c > a));
    return c;
}

function add(int256 a, int256 b) internal pure returns (int256) {
    int256 c = a + b;
    require((b >= 0 && c >= a) || (b < 0 && c < a));
    return c;
}

function abs(int256 a) internal pure returns (int256) {
    require(a != MIN_INT256);
    return a < 0 ? -a : a;
}

}

contract Ownable {
address private _owner;

event OwnershipRenounced(address indexed previousOwner);

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

constructor() {
    _owner = msg.sender;
}

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

modifier onlyOwner() {
    require(isOwner());
    _;
}

function isOwner() public view returns (bool) {
    return msg.sender == _owner;
}

function renounceOwnership() public onlyOwner {
    emit OwnershipRenounced(_owner);
    _owner = address(0);
}

function transferOwnership(address newOwner) public onlyOwner {
    _transferOwnership(newOwner);
}

function _transferOwnership(address newOwner) internal {
    require(newOwner != address(0));
    emit OwnershipTransferred(_owner, newOwner);
    _owner = newOwner;
}

}

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

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

function WETH() external pure returns (address);

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

function addLiquidityETH(
    address token,
    uint256 amountTokenDesired,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline
)
    external
    payable
    returns (
        uint256 amountToken,
        uint256 amountETH,
        uint256 liquidity
    );

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

function swapExactETHForTokensSupportingFeeOnTransferTokens(
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
) external payable;

function swapExactTokensForETHSupportingFeeOnTransferTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
) external;

}

contract MCC is ERC20Detailed, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;

event LogRebase(uint256 indexed epoch, uint256 totalSupply);

address public master;

InterfaceLP public pairContract;

modifier onlyMaster() {
    require(msg.sender == master);
    _;
}

bool public initialDistributionFinished;

mapping(address => bool) allowTransfer;
mapping(address => bool) _isFeeExempt;
mapping(address => bool) _isMaxWalletExempt;

modifier initialDistributionLock() {
    require(
        initialDistributionFinished ||
            isOwner() ||
            allowTransfer[msg.sender]
    );
    _;
}

modifier validRecipient(address to) {
    require(to != address(0x0));
    _;
}

uint256 private constant DECIMALS = 9;
uint256 private constant MAX_UINT256 = ~uint256(0);

uint256 private constant INITIAL_FRAGMENTS_SUPPLY = 10**15 * 10**DECIMALS;
uint256 public gonMaxWallet = TOTAL_GONS.div(100).mul(5);

uint256 public ecosystemFee = 1;
uint256 public liquidityFee = 3;
uint256 public marketingFee = 4;

    ecosystemFee.add(liquidityFee).add(marketingFee).add(buyBackFee);
uint256 public feeDenominator = 100;

address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;

address public autoLiquidityReceiver;
address public marketingFeeReceiver;
address public ecosystemFeeReceiver;


uint256 targetLiquidity = 50;
uint256 targetLiquidityDenominator = 100;

IDEXRouter public router;
address public pair;

bool public swapEnabled = true;
uint256 private gonSwapThreshold = (TOTAL_GONS * 10) / 10000;
bool inSwap;
modifier swapping() {
    inSwap = true;
    _;
    inSwap = false;
}

uint256 private constant TOTAL_GONS =
    MAX_UINT256 - (MAX_UINT256 % INITIAL_FRAGMENTS_SUPPLY);

uint256 private constant MAX_SUPPLY = ~uint128(0);

uint256 private _totalSupply;
uint256 private _gonsPerFragment;
mapping(address => uint256) private _gonBalances;

mapping(address => mapping(address => uint256)) private _allowedFragments;

function rebase(uint256 epoch, int256 supplyDelta)
    external
    onlyMaster
    returns (uint256)
{
    require(!inSwap, "Try again");
    if (supplyDelta == 0) {
        emit LogRebase(epoch, _totalSupply);
        return _totalSupply;
    }

    if (supplyDelta < 0) {
        _totalSupply = _totalSupply.sub(uint256(-supplyDelta));
    } else {
        _totalSupply = _totalSupply.add(uint256(supplyDelta));
    }

    if (_totalSupply > MAX_SUPPLY) {
        _totalSupply = MAX_SUPPLY;
    }

    _gonsPerFragment = TOTAL_GONS.div(_totalSupply);
    pairContract.sync();

    emit LogRebase(epoch, _totalSupply);
    return _totalSupply;
}

constructor() ERC20Detailed("MetaCasino", "MCC", uint8(DECIMALS)) {
    router = IDEXRouter(0x10ED43C718714eb63d5aA57B78B54704E256024E); //Sushi 0xeC6F73267ab491dE521f54C0295AE5Bf372f2e1f // Cake 0x10ED43C718714eb63d5aA57B78B54704E256024E

    pair = IDEXFactory(router.factory()).createPair(
        router.WETH(),
        address(this)
    );
    _allowedFragments[address(this)][address(router)] = uint256(-1);
    pairContract = InterfaceLP(pair);

    _totalSupply = INITIAL_FRAGMENTS_SUPPLY;
    _gonBalances[msg.sender] = TOTAL_GONS;
    _gonsPerFragment = TOTAL_GONS.div(_totalSupply);

    initialDistributionFinished = false;
    _isFeeExempt[msg.sender] = true;
    _isFeeExempt[address(this)] = true;

    _isMaxWalletExempt[pair] = true;
    _isMaxWalletExempt[DEAD] = true;
    _isMaxWalletExempt[address(this)] = true;
    _isMaxWalletExempt[msg.sender] = true;

    autoLiquidityReceiver = 0x309aB292a060D8606008424bd7a464265FbF5074;
    marketingFeeReceiver = 0x71A1B5013FF2045aEAe6fc7D96C408D5fAA844c2;
    ecosystemFeeReceiver = 0x04b803E6a081D4dA878e5e1fCa245F05EEd3736b;


    emit Transfer(address(0x0), msg.sender, _totalSupply);
}

function setMaster(address _master) external onlyOwner {
    master = _master;
}

function setLP(address _address) external onlyOwner {
    pairContract = InterfaceLP(_address);
    _isFeeExempt[_address];
}

function totalSupply() external view override returns (uint256) {
    return _totalSupply;
}

function balanceOf(address who) external view override returns (uint256) {
    return _gonBalances[who].div(_gonsPerFragment);
}

function transfer(address to, uint256 value)
    external
    override
    validRecipient(to)
    initialDistributionLock
    returns (bool)
{
    _transferFrom(msg.sender, to, value);
    return true;
}

function allowance(address owner_, address spender)
    external
    view
    override
    returns (uint256)
{
    return _allowedFragments[owner_][spender];
}

function transferFrom(
    address from,
    address to,
    uint256 value
) external override validRecipient(to) returns (bool) {
    if (_allowedFragments[from][msg.sender] != uint256(-1)) {
        _allowedFragments[from][msg.sender] = _allowedFragments[from][
            msg.sender
        ].sub(value, "Insufficient Allowance");
    }

    _transferFrom(from, to, value);
    return true;
}

function _transferFrom(
    address sender,
    address recipient,
    uint256 amount
) internal returns (bool) {
    if (inSwap) {
        return _basicTransfer(sender, recipient, amount);
    }

    uint256 gonAmount = amount.mul(_gonsPerFragment);

    if (sender != owner() && !_isMaxWalletExempt[recipient]) {
        uint256 heldGonBalance = _gonBalances[recipient];
        require(
            (heldGonBalance + gonAmount) <= gonMaxWallet,
            "Total Holding is currently limited, you can not buy that much."
        );
    }

    if (shouldSwapBack()) {
        swapBack();
    }

    _gonBalances[sender] = _gonBalances[sender].sub(gonAmount);

    uint256 gonAmountReceived = shouldTakeFee(sender)
        ? takeFee(sender, gonAmount)
        : gonAmount;
    _gonBalances[recipient] = _gonBalances[recipient].add(
        gonAmountReceived
    );

    emit Transfer(
        sender,
        recipient,
        gonAmountReceived.div(_gonsPerFragment)
    );
    return true;
}

function _basicTransfer(
    address from,
    address to,
    uint256 amount
) internal returns (bool) {
    uint256 gonAmount = amount.mul(_gonsPerFragment);
    _gonBalances[from] = _gonBalances[from].sub(gonAmount);
    _gonBalances[to] = _gonBalances[to].add(gonAmount);
    return true;
}

function takeFee(address sender, uint256 gonAmount)
    internal
    returns (uint256)
{
    uint256 feeAmount = gonAmount.mul(totalFee).div(feeDenominator);

    _gonBalances[address(this)] = _gonBalances[address(this)].add(
        feeAmount
    );
    emit Transfer(sender, address(this), feeAmount.div(_gonsPerFragment));

    return gonAmount.sub(feeAmount);
}

function swapBack() internal swapping {
    uint256 dynamicLiquidityFee = isOverLiquified(
        targetLiquidity,
        targetLiquidityDenominator
    )
        ? 0
        : liquidityFee;
    uint256 contractTokenBalance = _gonBalances[address(this)].div(
        _gonsPerFragment
    );
    uint256 amountToLiquify = contractTokenBalance
        .mul(dynamicLiquidityFee)
        .div(totalFee)
        .div(2);
    uint256 amountToSwap = contractTokenBalance.sub(amountToLiquify);

    address[] memory path = new address[](2);
    path[0] = address(this);
    path[1] = router.WETH();

    uint256 balanceBefore = address(this).balance;

    router.swapExactTokensForETHSupportingFeeOnTransferTokens(
        amountToSwap,
        0,
        path,
        address(this),
        block.timestamp
    );

    uint256 amountETH = address(this).balance.sub(balanceBefore);

    uint256 totalETHFee = totalFee.sub(dynamicLiquidityFee.div(2));

    uint256 amountETHLiquidity = amountETH
        .mul(dynamicLiquidityFee)
        .div(totalETHFee)
        .div(2);
    uint256 amountETHBuyBack = amountETH.mul(buyBackFee).div(totalETHFee);
    uint256 amountETHMarketing = amountETH.mul(marketingFee).div(
        totalETHFee
    );
    uint256 amountETHEco = amountETH.mul(ecosystemFee).div(totalETHFee);

    (bool success, ) = payable(marketingFeeReceiver).call{
        value: amountETHMarketing,
        gas: 30000
    }("");
    (success, ) = payable(buyBackFeeReceiver).call{
        value: amountETHBuyBack,
        gas: 30000
    }("");
    (success, ) = payable(ecosystemFeeReceiver).call{
        value: amountETHEco,
        gas: 30000
    }("");

    success = false;

    if (amountToLiquify > 0) {
        router.addLiquidityETH{value: amountETHLiquidity}(
            address(this),
            amountToLiquify,
            0,
            0,
            autoLiquidityReceiver,
            block.timestamp
        );
    }
}

function approve(address spender, uint256 value)
    external
    override
    initialDistributionLock
    returns (bool)
{
    _allowedFragments[msg.sender][spender] = value;
    emit Approval(msg.sender, spender, value);
    return true;
}

function increaseAllowance(address spender, uint256 addedValue)
    external
    initialDistributionLock
    returns (bool)
{
    _allowedFragments[msg.sender][spender] = _allowedFragments[msg.sender][
        spender
    ].add(addedValue);
    emit Approval(
        msg.sender,
        spender,
        _allowedFragments[msg.sender][spender]
    );
    return true;
}

function decreaseAllowance(address spender, uint256 subtractedValue)
    external
    initialDistributionLock
    returns (bool)
{
    uint256 oldValue = _allowedFragments[msg.sender][spender];
    if (subtractedValue >= oldValue) {
        _allowedFragments[msg.sender][spender] = 0;
    } else {
        _allowedFragments[msg.sender][spender] = oldValue.sub(
            subtractedValue
        );
    }
    emit Approval(
        msg.sender,
        spender,
        _allowedFragments[msg.sender][spender]
    );
    return true;
}

function setInitialDistributionFinished() external onlyOwner {
    initialDistributionFinished = true;
}

function enableTransfer(address _addr) external onlyOwner {
    allowTransfer[_addr] = true;
}

function setFeeExempt(address _addr) external onlyOwner {
    _isFeeExempt[_addr] = true;
}

function checkFeeExempt(address _addr) external view returns (bool) {
    return _isFeeExempt[_addr];
}

function setMaxWalletExempt(address _addr) external onlyOwner {
    _isMaxWalletExempt[_addr] = true;
}

function checkMaxWalletExempt(address _addr) external view returns (bool) {
    return _isMaxWalletExempt[_addr];
}

function setMaxWalletToken(uint256 _num, uint256 _denom)
    external
    onlyOwner
{
    gonMaxWallet = TOTAL_GONS.div(_denom).mul(_num);
}

function checkMaxWalletToken() external view returns (uint256) {
    return gonMaxWallet.div(_gonsPerFragment);
}

function shouldTakeFee(address from) internal view returns (bool) {
    return !_isFeeExempt[from];
}

function shouldSwapBack() internal view returns (bool) {
    return
        msg.sender != pair &&
        !inSwap &&
        swapEnabled &&
        _gonBalances[address(this)] >= gonSwapThreshold;
}

function setSwapBackSettings(
    bool _enabled,
    uint256 _num,
    uint256 _denom
) external onlyOwner {
    swapEnabled = _enabled;
    gonSwapThreshold = TOTAL_GONS.div(_denom).mul(_num);
}

function setTargetLiquidity(uint256 target, uint256 accuracy) external onlyOwner {
    targetLiquidity = target;
    targetLiquidityDenominator = accuracy;
}

function isNotInSwap() external view returns (bool) {
    return !inSwap;
}

function checkSwapThreshold() external view returns (uint256) {
    return gonSwapThreshold.div(_gonsPerFragment);
}

function manualSync() external {
    InterfaceLP(pair).sync();
}

function setFees(
    uint256 _ecosystemFee,
    uint256 _liquidityFee,
    uint256 _buyBackFee,
    uint256 _marketingFee,
    uint256 _feeDenominator
) external onlyOwner {
    ecosystemFee = _ecosystemFee;
    liquidityFee = _liquidityFee;
    buyBackFee = _buyBackFee;
    marketingFee = _marketingFee;
    totalFee = ecosystemFee.add(liquidityFee).add(marketingFee).add(buyBackFee);
    feeDenominator = _feeDenominator;
    require(totalFee < feeDenominator / 4);
}

function setFeeReceivers(
    address _autoLiquidityReceiver,
    address _ecosystemFeeReceiver,
    address _marketingFeeReceiver,
    address _buyBackFeeReceiver
) external onlyOwner {
    autoLiquidityReceiver = _autoLiquidityReceiver;
    ecosystemFeeReceiver = _ecosystemFeeReceiver;
    marketingFeeReceiver = _marketingFeeReceiver;
    buyBackFeeReceiver = _buyBackFeeReceiver;
}

function rescueToken(address tokenAddress, uint256 tokens)
    public
    onlyOwner
    returns (bool success)
{
    return ERC20Detailed(tokenAddress).transfer(msg.sender, tokens);
}

function clearStuckBalance(uint256 amountPercentage, address adr) external onlyOwner {
    uint256 amountETH = address(this).balance;
    payable(adr).transfer(
        (amountETH * amountPercentage) / 100
    );
}

function transferToAddressETH(address payable recipient, uint256 amount)
    private
{
    recipient.transfer(amount);
}

function getCirculatingSupply() public view returns (uint256) {
    return
        (TOTAL_GONS.sub(_gonBalances[DEAD]).sub(_gonBalances[ZERO])).div(
            _gonsPerFragment
        );
}

function sendPresale(address[] calldata recipients, uint256[] calldata values)
    external
    onlyOwner
{
  for (uint256 i = 0; i < recipients.length; i++) {
    _transferFrom(msg.sender, recipients[i], values[i]);
  }
}

function getLiquidityBacking(uint256 accuracy)
    public
    view
    returns (uint256)
{
    uint256 liquidityBalance = _gonBalances[pair].div(_gonsPerFragment);
    return
        accuracy.mul(liquidityBalance.mul(2)).div(getCirculatingSupply());
}

function isOverLiquified(uint256 target, uint256 accuracy)
    public
    view
    returns (bool)
{
    return getLiquidityBacking(accuracy) > target;
}

receive() external payable {}

}