Review Please - Rewards Token on Polygon

[Terence.tez]

Hi all, I am still learning so some stuff are cut and paste. Please take a look at the contract and see if it would work. What I am trying to achieve is 4% of buy and sell fees to liquidity, 4% rewards to holders, 2% to charity and 2% to Dev account. paid in XZAR ( South African Rand tether). Contract compiles and verifies on testnet, thanks.

// SPDX-License-Identifier: unlicensed
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;
    }
}

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

/**
 * ERC20 standard interface.
 */
interface IERC20 {
    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 getOwner() external view returns (address);

    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 Auth {
    address internal owner;
    mapping(address => bool) internal authorizations;

    constructor(address _owner) {
        owner = _owner;
        authorizations[_owner] = true;
    }

    modifier onlyOwner() {
        require(isOwner(msg.sender), "!OWNER");
        _;
    }

    modifier authorized() {
        require(isAuthorized(msg.sender), "!AUTHORIZED");
        _;
    }

    function authorize(address adr) public onlyOwner {
        authorizations[adr] = true;
    }

    function unauthorize(address adr) public onlyOwner {
        authorizations[adr] = false;
    }

    function isOwner(address account) public view returns (bool) {
        return account == owner;
    }

    function isAuthorized(address adr) public view returns (bool) {
        return authorizations[adr];
    }

    function transferOwnership(address payable adr) public onlyOwner {
        owner = adr;
        authorizations[adr] = true;
        emit OwnershipTransferred(adr);
    }

    event OwnershipTransferred(address owner);
}

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

interface InterfaceLP {
    function sync() external;
}

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

interface IDividendDistributor {
    function setDistributionCriteria(
        uint256 _minPeriod,
        uint256 _minDistribution
    ) external;

    function setShare(address shareholder, uint256 amount) external;

    function deposit() external payable;

    function process(uint256 gas) external;
}

contract DividendDistributor is IDividendDistributor {
    using SafeMath for uint256;

    address _token;

    struct Share {
        uint256 amount;
        uint256 totalExcluded;
        uint256 totalRealised;
    }

    IERC20 RWRD = IERC20(0x30DE46509Dbc3a491128F97be0aAf70dc7Ff33cB); //XZAR
    address WETH = 0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619;
    IDEXRouter router;

    address[] shareholders;
    mapping(address => uint256) shareholderIndexes;
    mapping(address => uint256) shareholderClaims;

    mapping(address => Share) public shares;

    uint256 public totalShares;
    uint256 public totalDividends;
    uint256 public totalDistributed;
    uint256 public dividendsPerShare;
    uint256 public dividendsPerShareAccuracyFactor = 10**36;

    uint256 public minPeriod = 45 * 60;
    uint256 public minDistribution = 1 * (10**8);

    uint256 currentIndex;

    bool initialized;
    modifier initialization() {
        require(!initialized);
        _;
        initialized = true;
    }

    modifier onlyToken() {
        require(msg.sender == _token);
        _;
    }

    constructor(address _router) {
        router = _router != address(0)
            ? IDEXRouter(_router)
            : IDEXRouter(0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff); //QUICKSWAP
        _token = msg.sender;
    }

    function setDistributionCriteria(
        uint256 _minPeriod,
        uint256 _minDistribution
    ) external override onlyToken {
        minPeriod = _minPeriod;
        minDistribution = _minDistribution;
    }

    function setShare(address shareholder, uint256 amount)
        external
        override
        onlyToken
    {
        if (shares[shareholder].amount > 0) {
            distributeDividend(shareholder);
        }

        if (amount > 0 && shares[shareholder].amount == 0) {
            addShareholder(shareholder);
        } else if (amount == 0 && shares[shareholder].amount > 0) {
            removeShareholder(shareholder);
        }

        totalShares = totalShares.sub(shares[shareholder].amount).add(amount);
        shares[shareholder].amount = amount;
        shares[shareholder].totalExcluded = getCumulativeDividends(
            shares[shareholder].amount
        );
    }

    function deposit() external payable override onlyToken {
        uint256 balanceBefore = RWRD.balanceOf(address(this));

        address[] memory path = new address[](2);
        path[0] = WETH;
        path[1] = address(RWRD);

        router.swapExactETHForTokensSupportingFeeOnTransferTokens{
            value: msg.value
        }(0, path, address(this), block.timestamp);

        uint256 amount = RWRD.balanceOf(address(this)).sub(balanceBefore);

        totalDividends = totalDividends.add(amount);
        dividendsPerShare = dividendsPerShare.add(
            dividendsPerShareAccuracyFactor.mul(amount).div(totalShares)
        );
    }

    function process(uint256 gas) external override onlyToken {
        uint256 shareholderCount = shareholders.length;

        if (shareholderCount == 0) {
            return;
        }

        uint256 gasUsed = 0;
        uint256 gasLeft = gasleft();

        uint256 iterations = 0;

        while (gasUsed < gas && iterations < shareholderCount) {
            if (currentIndex >= shareholderCount) {
                currentIndex = 0;
            }

            if (shouldDistribute(shareholders[currentIndex])) {
                distributeDividend(shareholders[currentIndex]);
            }

            gasUsed = gasUsed.add(gasLeft.sub(gasleft()));
            gasLeft = gasleft();
            currentIndex++;
            iterations++;
        }
    }

    function shouldDistribute(address shareholder)
        internal
        view
        returns (bool)
    {
        return
            shareholderClaims[shareholder] + minPeriod < block.timestamp &&
            getUnpaidEarnings(shareholder) > minDistribution;
    }

    function distributeDividend(address shareholder) internal {
        if (shares[shareholder].amount == 0) {
            return;
        }

        uint256 amount = getUnpaidEarnings(shareholder);
        if (amount > 0) {
            totalDistributed = totalDistributed.add(amount);
            RWRD.transfer(shareholder, amount);
            shareholderClaims[shareholder] = block.timestamp;
            shares[shareholder].totalRealised = shares[shareholder]
                .totalRealised
                .add(amount);
            shares[shareholder].totalExcluded = getCumulativeDividends(
                shares[shareholder].amount
            );
        }
    }

    function claimDividend() external {
        distributeDividend(msg.sender);
    }

    function getUnpaidEarnings(address shareholder)
        public
        view
        returns (uint256)
    {
        if (shares[shareholder].amount == 0) {
            return 0;
        }

        uint256 shareholderTotalDividends = getCumulativeDividends(
            shares[shareholder].amount
        );
        uint256 shareholderTotalExcluded = shares[shareholder].totalExcluded;

        if (shareholderTotalDividends <= shareholderTotalExcluded) {
            return 0;
        }

        return shareholderTotalDividends.sub(shareholderTotalExcluded);
    }

    function getCumulativeDividends(uint256 share)
        internal
        view
        returns (uint256)
    {
        return
            share.mul(dividendsPerShare).div(dividendsPerShareAccuracyFactor);
    }

    function addShareholder(address shareholder) internal {
        shareholderIndexes[shareholder] = shareholders.length;
        shareholders.push(shareholder);
    }

    function removeShareholder(address shareholder) internal {
        shareholders[shareholderIndexes[shareholder]] = shareholders[
            shareholders.length - 1
        ];
        shareholderIndexes[
            shareholders[shareholders.length - 1]
        ] = shareholderIndexes[shareholder];
        shareholders.pop();
    }
}

contract AXD is IERC20, Auth {
    using SafeMath for uint256;
    using SafeMathInt for int256;

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

    string constant _name = "$AFRICAN";
    string constant _symbol = "AXD";
    uint8 constant _decimals = 9;

    //mapping (address => uint256) _balances;
    mapping(address => uint256) _rBalance;
    mapping(address => mapping(address => uint256)) _allowances;

    mapping(address => bool) public isFeeExempt;
    mapping(address => bool) public isTxLimitExempt;
    mapping(address => bool) public isTimelockExempt;
    mapping(address => bool) public isDividendExempt;

    uint256 public liquidityFee = 4;
    uint256 public reflectionFee = 4;
    uint256 public charityFee = 2;
    uint256 public devFee = 1;
    uint256 public totalFee =
        charityFee + reflectionFee + liquidityFee + devFee;
    uint256 public feeDenominator = 100;

    // Anti-Bot v2
    uint256 public maxRoomRent = 8000000000;
    bool public AntiBotMode = false;
    mapping(address => bool) public isHouseguest;

    uint256 public deadBlocks = 2;
    uint256 public launchedAt = 0;

    uint256 public sellMultiplier = 100;

    address public autoLiquidityReceiver;
    address public charityFeeReceiver;
    address public devFeeReceiver;

    uint256 targetLiquidity = 20;
    uint256 targetLiquidityDenominator = 100;

    IDEXRouter public router;
    address public pair;
    InterfaceLP public pairContract;

    bool public tradingOpen = false;

    DividendDistributor public distributor;
    uint256 distributorGas = 500000;

    bool public buyCooldownEnabled = false;
    uint8 public cooldownTimerInterval = 10;
    mapping(address => uint256) private cooldownTimer;

    bool public swapEnabled = false;
    bool inSwap;
    modifier swapping() {
        inSwap = true;
        _;
        inSwap = false;
    }

    address public master;
    modifier onlyMaster() {
        require(msg.sender == master || isOwner(msg.sender));
        _;
    }

    event AntiBotCheckin(address guest, uint256 rentPaid);

    uint256 private constant INITIAL_FRAGMENTS_SUPPLY = 10**9 * 10**_decimals;
    uint256 public swapThreshold = (rSupply * 10) / 10000;
    uint256 public rate;
    uint256 public _totalSupply;
    uint256 private constant MAX_UINT256 = ~uint256(0);
    uint256 private constant MAX_SUPPLY = ~uint128(0);
    uint256 private constant rSupply =
        MAX_UINT256 - (MAX_UINT256 % INITIAL_FRAGMENTS_SUPPLY);

    // Max wallet & Transaction
    uint256 public _maxTxAmount = rSupply.div(100).mul(2);
    uint256 public _maxWalletToken = rSupply.div(100).mul(3);

    constructor() Auth(msg.sender) {
       // Quickswap testnet 0xbdd4e5660839a088573191A9889A262c0Efc0983
        router = IDEXRouter(0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff); //QUICKSWAP
        pair = IDEXFactory(router.factory()).createPair(WMATIC, address(this));
        _allowances[address(this)][address(router)] = uint256(-1);

        pairContract = InterfaceLP(pair);
        _totalSupply = INITIAL_FRAGMENTS_SUPPLY;
        rate = rSupply.div(_totalSupply);

        distributor = new DividendDistributor(address(router));

        isFeeExempt[msg.sender] = true;
        isTxLimitExempt[msg.sender] = true;

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

        isDividendExempt[pair] = true;
        isDividendExempt[address(this)] = true;
        isDividendExempt[DEAD] = true;

        autoLiquidityReceiver = msg.sender;
        charityFeeReceiver = 0x94d2Ab69A7d0f3169EE0b704760Ca4F1e28cfD74; // Charity Wallet
        devFeeReceiver = 0x990e301061E5e85d590dfbA0170002FE29aF07d1; // Buybacks and project developments

        _rBalance[msg.sender] = rSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }

    receive() external payable {}

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

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

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

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

    function getOwner() external view override returns (address) {
        return owner;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _rBalance[account].div(rate);
    }

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

    function approve(address spender, uint256 amount)
        public
        override
        returns (bool)
    {
        _allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function approveMax(address spender) external returns (bool) {
        return approve(spender, uint256(-1));
    }

    function transfer(address recipient, uint256 amount)
        external
        override
        returns (bool)
    {
        return _transferFrom(msg.sender, recipient, amount);
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external override returns (bool) {
        if (_allowances[sender][msg.sender] != uint256(-1)) {
            _allowances[sender][msg.sender] = _allowances[sender][msg.sender]
                .sub(amount, "Insufficient Allowance");
        }

        return _transferFrom(sender, recipient, amount);
    }

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

        if (!authorizations[sender] && !authorizations[recipient]) {
            require(tradingOpen, "Trading not open yet");
        }

        uint256 rAmount = amount.mul(rate);

        if (
            !authorizations[sender] &&
            recipient != address(this) &&
            recipient != address(DEAD) &&
            recipient != pair &&
            recipient != charityFeeReceiver &&
            recipient != devFeeReceiver &&
            recipient != autoLiquidityReceiver
        ) {
            uint256 heldTokens = balanceOf(recipient);
            require(
                (heldTokens + rAmount) <= _maxWalletToken,
                "Total Holding is currently limited, you can not buy that much."
            );
        }

        if (
            sender == pair && buyCooldownEnabled && !isTimelockExempt[recipient]
        ) {
            require(
                cooldownTimer[recipient] < block.timestamp,
                "buy Cooldown exists"
            );
            cooldownTimer[recipient] = block.timestamp + cooldownTimerInterval;
        }

        if (AntiBotMode) {
            require(!isHouseguest[sender], "Bots cant sell");
            if (tx.gasprice > maxRoomRent && sender == pair) {
                isHouseguest[recipient] = true;
                emit AntiBotCheckin(recipient, tx.gasprice);
            }
        }

        // Checks max transaction limit
        checkTxLimit(sender, rAmount);

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

        //Exchange tokens
        _rBalance[sender] = _rBalance[sender].sub(
            rAmount,
            "Insufficient Balance"
        );

        uint256 amountReceived = (!shouldTakeFee(sender) ||
            !shouldTakeFee(recipient))
            ? rAmount
            : takeFee(sender, rAmount, (recipient == pair));
        _rBalance[recipient] = _rBalance[recipient].add(amountReceived);

        // Dividend tracker
        if (!isDividendExempt[sender]) {
            try distributor.setShare(sender, balanceOf(sender)) {} catch {}
        }

        if (!isDividendExempt[recipient]) {
            try
                distributor.setShare(recipient, balanceOf(recipient))
            {} catch {}
        }

        try distributor.process(distributorGas) {} catch {}

        emit Transfer(sender, recipient, amountReceived.div(rate));
        return true;
    }

    // Changed

    function _basicTransfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal returns (bool) {
        uint256 rAmount = amount.mul(rate);
        _rBalance[sender] = _rBalance[sender].sub(
            rAmount,
            "Insufficient Balance"
        );
        _rBalance[recipient] = _rBalance[recipient].add(rAmount);
        emit Transfer(sender, recipient, rAmount.div(rate));
        return true;
    }

    function checkTxLimit(address sender, uint256 rAmount) internal view {
        require(
            rAmount <= _maxTxAmount || isTxLimitExempt[sender],
            "TX Limit Exceeded"
        );
    }

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

    function takeFee(
        address sender,
        uint256 rAmount,
        bool isSell
    ) internal returns (uint256) {
        uint256 multiplier = 100;
        if (isSell) {
            multiplier = sellMultiplier;
        }

        uint256 feeAmount = rAmount.div(feeDenominator * 100).mul(totalFee).mul(
            multiplier
        );

        if (!isSell && (launchedAt + deadBlocks) > block.number) {
            feeAmount = rAmount.div(100).mul(99);
        }

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

        return rAmount.sub(feeAmount);
    }

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

    function clearStuckBalance(uint256 amountPercentage) external authorized {
        uint256 amountMATIC = address(this).balance;
        payable(charityFeeReceiver).transfer(
            (amountMATIC * amountPercentage) / 100
        );
    }

    function clearStuckBalance_sender(uint256 amountPercentage)
        external
        authorized
    {
        uint256 amountMATIC = address(this).balance;
        payable(msg.sender).transfer((amountMATIC * amountPercentage) / 100);
    }

    function set_sell_multiplier(uint256 Multiplier) external onlyOwner {
        sellMultiplier = Multiplier;
    }

    // switch Trading

    function tradingStatus(bool _status, uint256 _deadBlocks) public onlyOwner {
        tradingOpen = _status;
        if (tradingOpen && launchedAt == 0) {
            launchedAt = block.number;
            deadBlocks = _deadBlocks;
        }
    }

    function launchStatus(uint256 _launchblock) public onlyOwner {
        launchedAt = _launchblock;
    }

    // Anti Bot manager
    function enable_Anti_BotMode(bool _status) public onlyOwner {
        AntiBotMode = _status;
    }

    function set_max_roomrent(uint256 _rent_withoutdecimal) public onlyOwner {
        maxRoomRent = _rent_withoutdecimal * 10**9;
    }

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

    function cooldownEnabled(bool _status, uint8 _interval) public onlyOwner {
        buyCooldownEnabled = _status;
        cooldownTimerInterval = _interval;
    }

    // OK, check 3
    function swapBack() internal swapping {
        uint256 dynamicLiquidityFee = isOverLiquified(
            targetLiquidity,
            targetLiquidityDenominator
        )
            ? 0
            : liquidityFee;
        uint256 tokensToSell = swapThreshold.div(rate);

        uint256 amountToLiquify = tokensToSell
            .div(totalFee)
            .mul(dynamicLiquidityFee)
            .div(2);
        uint256 amountToSwap = tokensToSell.sub(amountToLiquify);

        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = WMATIC;

        uint256 balanceBefore = address(this).balance;

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

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

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

        uint256 amountMATICLiquidity = amountMATIC
            .mul(dynamicLiquidityFee)
            .div(totalMATICFee)
            .div(2);
        uint256 amountMATICReflection = amountMATIC.mul(reflectionFee).div(
            totalMATICFee
        );
        uint256 amountMATICMarketing = amountMATIC.mul(charityFee).div(
            totalMATICFee
        );
        uint256 amountMATICDev = amountMATIC.mul(devFee).div(totalMATICFee);

        try distributor.deposit{value: amountMATICReflection}() {} catch {}
        (bool tmpSuccess, ) = payable(charityFeeReceiver).call{
            value: amountMATICMarketing,
            gas: 30000
        }("");
        (tmpSuccess, ) = payable(devFeeReceiver).call{
            value: amountMATICDev,
            gas: 30000
        }("");

        // only to supress warning msg
        tmpSuccess = false;

        if (amountToLiquify > 0) {
            router.addLiquidityETH{value: amountMATICLiquidity}(
                address(this),
                amountToLiquify,
                0,
                0,
                autoLiquidityReceiver,
                block.timestamp
            );
            emit AutoLiquify(amountMATICLiquidity, amountToLiquify.div(rate));
        }
    }

    function setIsDividendExempt(address holder, bool exempt)
        external
        authorized
    {
        require(holder != address(this) && holder != pair);
        isDividendExempt[holder] = exempt;
        if (exempt) {
            distributor.setShare(holder, 0);
        } else {
            distributor.setShare(holder, balanceOf(holder));
        }
    }

    function setIsFeeExempt(address holder, bool exempt) external authorized {
        isFeeExempt[holder] = exempt;
    }

    function setIsTxLimitExempt(address holder, bool exempt)
        external
        authorized
    {
        isTxLimitExempt[holder] = exempt;
    }

    function setIsTimelockExempt(address holder, bool exempt)
        external
        authorized
    {
        isTimelockExempt[holder] = exempt;
    }

    function setFees(
        uint256 _liquidityFee,
        uint256 _reflectionFee,
        uint256 _charityFee,
        uint256 _devFee,
        uint256 _feeDenominator
    ) external authorized {
        liquidityFee = _liquidityFee;
        reflectionFee = _reflectionFee;
        charityFee = _charityFee;
        devFee = _devFee;
        totalFee = _liquidityFee.add(_reflectionFee).add(_charityFee).add(
            _devFee
        );
        feeDenominator = _feeDenominator;
        require(totalFee < feeDenominator / 3, "Fees cannot be more than 33%");
    }

    function setFeeReceivers(
        address _autoLiquidityReceiver,
        address _charityFeeReceiver,
        address _devFeeReceiver
    ) external authorized {
        autoLiquidityReceiver = _autoLiquidityReceiver;
        charityFeeReceiver = _charityFeeReceiver;
        devFeeReceiver = _devFeeReceiver;
    }

    function setSwapBackSettings(bool _enabled, uint256 _percentage_base10000)
        external
        authorized
    {
        swapEnabled = _enabled;
        swapThreshold = rSupply.div(10000).mul(_percentage_base10000);
    }

    function setTargetLiquidity(uint256 _target, uint256 _denominator)
        external
        authorized
    {
        targetLiquidity = _target;
        targetLiquidityDenominator = _denominator;
    }

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

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

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

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

    function checkSwapThreshold() external view returns (uint256) {
        return swapThreshold.div(rate);
    }

    function setDistributionCriteria(
        uint256 _minPeriod,
        uint256 _minDistribution
    ) external authorized {
        distributor.setDistributionCriteria(_minPeriod, _minDistribution);
    }

    function setDistributorSettings(uint256 gas) external authorized {
        require(gas < 900000);
        distributorGas = gas;
    }

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

    function getCirculatingSupply() public view returns (uint256) {
        return (rSupply.sub(_rBalance[DEAD]).sub(_rBalance[ZERO])).div(rate);
    }

    function getLiquidityBacking(uint256 accuracy)
        public
        view
        returns (uint256)
    {
        return accuracy.mul(balanceOf(pair).mul(2)).div(getCirculatingSupply());
    }

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

    function checkMaxWalletToken() external view returns (uint256) {
        return _maxWalletToken.div(rate);
    }

    function checkMaxTxAmount() external view returns (uint256) {
        return _maxTxAmount.div(rate);
    }

    function setMaxWalletPercent_base1000(uint256 maxWallPercent_base1000)
        external
        onlyOwner
    {
        _maxWalletToken = rSupply.div(1000).mul(maxWallPercent_base1000);
    }

    function setMaxTxPercent_base1000(uint256 maxTXPercentage_base1000)
        external
        onlyOwner
    {
        _maxTxAmount = rSupply.div(1000).mul(maxTXPercentage_base1000);
    }

    /* Airdrop Begins */

    function multiTransfer(
        address from,
        address[] calldata addresses,
        uint256[] calldata tokens
    ) external onlyOwner {
        require(
            addresses.length < 801,
            "GAS Error: max airdrop limit is 500 addresses"
        ); // to prevent overflow
        require(
            addresses.length == tokens.length,
            "Mismatch between Address and token count"
        );

        uint256 SCCC = 0;

        for (uint256 i = 0; i < addresses.length; i++) {
            SCCC = SCCC + tokens[i];
        }

        require(balanceOf(from) >= SCCC, "Not enough tokens in wallet");

        for (uint256 i = 0; i < addresses.length; i++) {
            _basicTransfer(from, addresses[i], tokens[i]);
            if (!isDividendExempt[addresses[i]]) {
                try
                    distributor.setShare(addresses[i], balanceOf(addresses[i]))
                {} catch {}
            }
        }

        // Dividend tracker
        if (!isDividendExempt[from]) {
            try distributor.setShare(from, balanceOf(from)) {} catch {}
        }
    }

    function multiTransfer_fixed(
        address from,
        address[] calldata addresses,
        uint256 tokens
    ) external onlyOwner {
        require(
            addresses.length < 2001,
            "GAS Error: max airdrop limit is 2000 addresses"
        ); // to prevent overflow

        uint256 SCCC = tokens * addresses.length;

        require(balanceOf(from) >= SCCC, "Not enough tokens in wallet");

        for (uint256 i = 0; i < addresses.length; i++) {
            _basicTransfer(from, addresses[i], tokens);
            if (!isDividendExempt[addresses[i]]) {
                try
                    distributor.setShare(addresses[i], balanceOf(addresses[i]))
                {} catch {}
            }
        }

        // Dividend tracker
        if (!isDividendExempt[from]) {
            try distributor.setShare(from, balanceOf(from)) {} catch {}
        }
    }


    event AutoLiquify(uint256 amountMATIC, uint256 amountTokens);
}

[peroxide]

did you get this sorted out? is there liquidity for the reward token on quickswap testnet? if there isn't, it can't swap and pay divs.

also here, Uint256 needs to be in the hundreds for each percent.

>  string constant _name = "$AFRICAN";
>     string constant _symbol = "AXD";
>     uint8 constant _decimals = 9;
> 
>     //mapping (address => uint256) _balances;
>     mapping(address => uint256) _rBalance;
>     mapping(address => mapping(address => uint256)) _allowances;
> 
>     mapping(address => bool) public isFeeExempt;
>     mapping(address => bool) public isTxLimitExempt;
>     mapping(address => bool) public isTimelockExempt;
>     mapping(address => bool) public isDividendExempt;
> 
>     uint256 public liquidityFee = 400;
>     uint256 public reflectionFee = 400;
>     uint256 public charityFee = 200;
>     uint256 public devFee = 100;
>     uint256 public totalFee = 1100;
>     uint256 public feeDenominator = 1100;

and also here, this WETH address needs to be WMATIC in your case. you have a random wallet address pasted there. if you see a random WETH in a contract you fork, it's usually safe to assume it's the wrapped native token of that chain.

> IERC20 RWRD = IERC20(0x30DE46509Dbc3a491128F97be0aAf70dc7Ff33cB); //XZAR
> 
>     address WETH = 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270;
> 
>     IDEXRouter router;
> 
>     address[] shareholders;
> 
>     mapping(address => uint256) shareholderIndexes;
> 
>     mapping(address => uint256) shareholderClaims;
> 
>     mapping(address => Share) public shares;

also, your XZAR reward token does not exist on testnet. which means it will not work unless you deploy a copy of XZAR onto testnet, and add liquidity to quickswap testnet. or just try it on mainnet under a different name?

i just deployed and verified on bsc testnet, it should work fine but I accidentally left the polygon gas settings for the distributor LOL. but it looks like it works decent, one more IMPORTANT thing is the swap threshold is extremely high. needs to be lowered if anyone wants to earn dividends from swaps

AAAAA (XD) Token Tracker | BscScan

[serpaul]

Hey Peroxide,

I have a similar situation.

The contract im looking at is on bsc with a total supply of 1T coins and swapback is at 5B coins

I can see the dev changing the setswapbacksettings functions regularly varying between 1B to 6B
Is there a reason why he is doin this?
And is it safe to keep it at 5B and never have to worry about changing it ever?
This is the contract in question: https://bscscan.com/address/0xae2c059f3dfc51aba66c1e38f334643708dc0fe9#code

Thanks