# Review Please - Rewards Token on Polygon

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

external
returns (bool);

external
view
returns (uint256);

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

function transferFrom(
uint256 amount
) external returns (bool);

event Approval(
uint256 value
);
}

abstract contract Auth {

owner = _owner;
authorizations[_owner] = true;
}

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

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

}

}

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

}

}

}

interface IDEXFactory {
external
}

interface InterfaceLP {
function sync() external;
}

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

function WETH() external pure returns (address);

uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);

uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);

function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
) external;

function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
) external payable;

function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
) 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;

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

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

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

? IDEXRouter(_router)
: IDEXRouter(0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff); //QUICKSWAP
_token = msg.sender;
}

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

external
override
onlyToken
{
if (shares[shareholder].amount > 0) {
distributeDividend(shareholder);
}

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

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

function deposit() external payable override onlyToken {

path[0] = WETH;

router.swapExactETHForTokensSupportingFeeOnTransferTokens{
value: msg.value

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

gasLeft = gasleft();
currentIndex++;
iterations++;
}
}

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

if (shares[shareholder].amount == 0) {
return;
}

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

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

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

shareholderIndexes[shareholder] = shareholders.length;
shareholders.push(shareholder);
}

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;

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

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;

uint256 public launchedAt = 0;

uint256 public sellMultiplier = 100;

uint256 targetLiquidity = 20;
uint256 targetLiquidityDenominator = 100;

IDEXRouter public router;
InterfaceLP public pairContract;

DividendDistributor public distributor;
uint256 distributorGas = 500000;

uint8 public cooldownTimerInterval = 10;

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

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

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

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

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

isTimelockExempt[msg.sender] = true;

isDividendExempt[pair] = true;

charityFeeReceiver = 0x94d2Ab69A7d0f3169EE0b704760Ca4F1e28cfD74; // Charity Wallet

_rBalance[msg.sender] = rSupply;
}

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

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

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

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

function transferFrom(
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(
uint256 amount
) internal returns (bool) {
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}

if (!authorizations[sender] && !authorizations[recipient]) {
}

uint256 rAmount = amount.mul(rate);

if (
!authorizations[sender] &&
recipient != pair &&
) {
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,
);
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"
);

!shouldTakeFee(recipient))
? rAmount
: takeFee(sender, rAmount, (recipient == pair));

// 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 {}

return true;
}

// Changed

function _basicTransfer(
uint256 amount
) internal returns (bool) {
uint256 rAmount = amount.mul(rate);
_rBalance[sender] = _rBalance[sender].sub(
rAmount,
"Insufficient Balance"
);
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(
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);
}

return rAmount.sub(feeAmount);
}

function shouldSwapBack() internal view returns (bool) {
return
msg.sender != pair &&
!inSwap &&
swapEnabled &&
}

function clearStuckBalance(uint256 amountPercentage) external authorized {
(amountMATIC * amountPercentage) / 100
);
}

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

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

if (tradingOpen && launchedAt == 0) {
launchedAt = block.number;
}
}

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

public
onlyOwner
{
for (uint256 i; i < addresses.length; ++i) {
}
}

function cooldownEnabled(bool _status, uint8 _interval) public onlyOwner {
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);

path[1] = WMATIC;

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

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 {}
value: amountMATICMarketing,
gas: 30000
}("");
value: amountMATICDev,
gas: 30000
}("");

// only to supress warning msg
tmpSuccess = false;

if (amountToLiquify > 0) {
amountToLiquify,
0,
0,
block.timestamp
);
emit AutoLiquify(amountMATICLiquidity, amountToLiquify.div(rate));
}
}

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

external
authorized
{
isTxLimitExempt[holder] = 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;
_devFee
);
feeDenominator = _feeDenominator;
require(totalFee < feeDenominator / 3, "Fees cannot be more than 33%");
}

) external authorized {
}

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

public
onlyOwner
returns (bool success)
{
}

function getCirculatingSupply() public view returns (uint256) {
}

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(
uint256[] calldata tokens
) external onlyOwner {
require(
"GAS Error: max airdrop limit is 500 addresses"
); // to prevent overflow
require(
"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++) {
try
{} catch {}
}
}

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

function multiTransfer_fixed(
uint256 tokens
) external onlyOwner {
require(
"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++) {
try
{} catch {}
}
}

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

event AutoLiquify(uint256 amountMATIC, uint256 amountTokens);
}
``````

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 => 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
>
>
>     IDEXRouter router;
>
>
>
>
>     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

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