Hey! I have made a reward token contract, where i want to be able to switch the tokens my project gives in rewards. I have made the contract public in the code, and a function to be able to change it. But when i update it on bscscan on "write", the project still gives out the old one in rewards. Are anybody able to help me to see whats needed to be changed to make it work? Here is the code i modified to Cronos, but basically the same as BEP-20:
/**
MAKE SURE YOU BUY THE RIGHT TOKEN, THERE WILL BE MANY FAKES! TEAM WILL NEVER DM YOU FIRST, ASK FOR FUNDS OR NEVER ASK FOR YOU SECRET(!) SEED PHRASE!
GREEN CHART ONLY!
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
/**
* Standard SafeMath, stripped down to just add/sub/mul/div
*/
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) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
/**
* BEP20 standard interface.
*/
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function 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);
}
/**
* Allows for contract ownership for multiple adressess
*/
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
owner = _owner;
authorizations[_owner] = true;
}
/**
* Function modifier to require caller to be contract owner
*/
modifier onlyOwner() {
require(isOwner(msg.sender), "!OWNER"); _;
}
/**
* Function modifier to require caller to be authorized
*/
modifier authorized() {
require(isAuthorized(msg.sender), "!AUTHORIZED"); _;
}
/**
* Authorize address. Owner only
*/
function authorize(address account) public onlyOwner {
authorizations[account] = true;
}
/**
* Remove address authorization. Owner only
*/
function unauthorize(address account) public onlyOwner {
authorizations[account] = false;
}
/**
* Check if address is owner
*/
function isOwner(address account) public view returns (bool) {
return account == owner;
}
/**
* Return address authorization status
*/
function isAuthorized(address account) public view returns (bool) {
return authorizations[account];
}
/**
* Transfer ownership to new address. Caller must be owner. Leaves old owner authorized
*/
function transferOwnership(address payable account) public onlyOwner {
owner = account;
authorizations[account] = true;
emit OwnershipTransferred(account);
}
event OwnershipTransferred(address owner);
}
/* Standard IDEXFactory */
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
/* Standard IDEXRouter */
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
/* Interface for the DividendDistributor */
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;
}
/* Our DividendDistributor contract responsible for distributing the earn token */
contract DividendDistributor is IDividendDistributor {
using SafeMath for uint256;
address _token;
struct Share {
uint256 amount;
uint256 totalExcluded;
uint256 totalRealised;
}
// EARN (Starting reward(RWRD) is USDC)
IBEP20 public RWRD = IBEP20(0xC4a174cCb5fb54a6721e11e0Ca961e42715023F9);
address WCRO = 0x5C7F8A570d578ED84E63fdFA7b1eE72dEae1AE23;
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 = 30 * 60;
uint256 public minDistribution = 1 * (10 ** 12);
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(0x145677FC4d9b8F19B5D56d1820c48e0443049a30); //MMFROUTER
_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] = WCRO;
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(address shareholder) external onlyToken{
distributeDividend(shareholder);
}
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();
}
}
/* Token contract */
contract TEST is IBEP20, Auth {
using SafeMath for uint256;
// Addresses
address public RWRD = 0xC4a174cCb5fb54a6721e11e0Ca961e42715023F9; //CROGE
address WCRO = 0x5C7F8A570d578ED84E63fdFA7b1eE72dEae1AE23;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
// These are owner by default
address public autoLiquidityReceiver;
address public marketingFeeReceiver;
address public devFeeReceiver;
// Name and symbol
string constant _name = "TEST";
string constant _symbol = "TEST";
uint8 constant _decimals = 18;
// Total supply
uint256 _totalSupply = 100000000 * (10 ** _decimals); // 100m
// Max wallet and TX
uint256 public _maxBuyTxAmount = _totalSupply * 200 / 10000; // 2% on launch or 2M tokens
uint256 public _maxSellTxAmount = _totalSupply * 100 / 10000; // 1% or 1M tokens
uint256 public _maxWalletToken = ( _totalSupply * 200 ) / 10000; // 2% or 2m tokens
// Mappings
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping (address => bool) isTimelockExempt;
mapping (address => bool) isDividendExempt;
mapping (address => bool) public isHotelCaliforniamode;
// Buy Fees
uint256 public liquidityFeeBuy = 1;
uint256 public buybackFeeBuy = 0;
uint256 public reflectionFeeBuy = 8;
uint256 public marketingFeeBuy = 2;
uint256 public devFeeBuy = 1;
uint256 public totalFeeBuy = 12;
// Sell fees
uint256 public liquidityFeeSell = 2;
uint256 public buybackFeeSell = 0;
uint256 public reflectionFeeSell = 7;
uint256 public marketingFeeSell = 2;
uint256 public devFeeSell = 1;
uint256 public totalFeeSell = 12;
// Fee variables
uint256 liquidityFee;
uint256 buybackFee;
uint256 reflectionFee;
uint256 marketingFee;
uint256 devFee;
uint256 totalFee;
uint256 feeDenominator = 100;
// GREED
uint256 GREEDTriggeredAt;
uint256 GREEDDuration = 3600;
// Dead blocks
uint256 deadBlocks = 3;
// Sell amount of tokens when a sell takes place
uint256 public swapThreshold = _totalSupply * 10 / 10000; // 0,1% of supply
// Liquidity
uint256 targetLiquidity = 20;
uint256 targetLiquidityDenominator = 100;
// Buyback settings
uint256 buybackMultiplierNumerator = 300;
uint256 buybackMultiplierDenominator = 100;
uint256 buybackMultiplierTriggeredAt;
uint256 buybackMultiplierLength = 30 minutes;
bool public autoBuybackEnabled = false;
bool public autoBuybackMultiplier = false;
uint256 autoBuybackCap;
uint256 autoBuybackAccumulator;
uint256 autoBuybackAmount;
uint256 autoBuybackBlockPeriod;
uint256 autoBuybackBlockLast;
DividendDistributor distributor;
uint256 distributorGas = 500000;
// Cooldown & timer functionality
bool public buyCooldownEnabled = false;
uint8 public cooldownTimerInterval = 30;
mapping (address => uint) private cooldownTimer;
// Other variables
IDEXRouter public router;
address public pair;
uint256 public launchedAt;
bool public tradingOpen = true;
bool public swapEnabled = true;
bool inSwap;
modifier swapping() { inSwap = true; _; inSwap = false; }
/* Token constructor */
constructor () Auth(msg.sender) {
router = IDEXRouter(0x145677FC4d9b8F19B5D56d1820c48e0443049a30);
pair = IDEXFactory(router.factory()).createPair(WCRO, address(this));
_allowances[address(this)][address(router)] = type(uint256).max;
distributor = new DividendDistributor(address(router));
// Should be the owner wallet/token distributor
address _presaler = msg.sender;
isFeeExempt[_presaler] = true;
isTxLimitExempt[_presaler] = true;
// No timelock for these people
isTimelockExempt[msg.sender] = true;
isTimelockExempt[DEAD] = true;
isTimelockExempt[address(this)] = true;
// Exempt from dividend
isDividendExempt[pair] = true;
isDividendExempt[address(this)] = true;
isDividendExempt[DEAD] = true;
// Set the marketing, dev and liq receiver to the owner as default
autoLiquidityReceiver = msg.sender;
marketingFeeReceiver = 0x783ea5BF5c444d220cE87980890F26638098346f;
devFeeReceiver = 0x953423Db9283ff8E64E9d563577B40456e22D9Cf;
_balances[_presaler] = _totalSupply;
emit Transfer(address(0), _presaler, _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 _balances[account]; }
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, type(uint256).max);
}
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] != type(uint256).max){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance");
}
return _transferFrom(sender, recipient, amount);
}
// setting the max wallet in percentages
// 1% = 100
function setMaxWalletPercent(uint256 maxWallPercent) external onlyOwner() {
_maxWalletToken = _totalSupply.mul(maxWallPercent).div(10000);
}
// Main transfer function
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
// Check if trading is enabled
if(!authorizations[sender] && !authorizations[recipient]){
require(tradingOpen,"Trading not enabled yet");
}
// Check if address is in Hotel Californiamode
require(!isHotelCaliforniamode[recipient] && !isHotelCaliforniamode[sender], 'Address is HotelCaliforniamode');
// Check if buying or selling
bool isSell = recipient == pair;
// Set buy or sell fees
setCorrectFees(isSell);
// Check max wallet
checkMaxWallet(sender, recipient, amount);
// Buycooldown
checkBuyCooldown(sender, recipient);
// Checks maxTx
checkTxLimit(sender, amount, recipient, isSell);
// Check if we are in GREEDTime
bool GREEDMode = inGREEDTime();
// Check if we should do the swapback
if(shouldSwapBack()){ swapBack(); }
//Exchange tokens
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = shouldTakeFee(sender) ? takeFee(sender, amount, isSell, GREEDMode) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
// Dividend tracker
if(!isDividendExempt[sender]) {
try distributor.setShare(sender, _balances[sender]) {} catch {}
}
if(!isDividendExempt[recipient]) {
try distributor.setShare(recipient, _balances[recipient]) {} catch {}
}
try distributor.process(distributorGas) {} catch {}
emit Transfer(sender, recipient, amountReceived);
return true;
}
// Do a normal transfer
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
// Set the correct fees for buying or selling
function setCorrectFees(bool isSell) internal {
if(isSell){
liquidityFee = liquidityFeeSell;
buybackFee = buybackFeeSell;
reflectionFee = reflectionFeeSell;
marketingFee = marketingFeeSell;
devFee = devFeeSell;
totalFee = totalFeeSell;
} else {
liquidityFee = liquidityFeeBuy;
buybackFee = buybackFeeBuy;
reflectionFee = reflectionFeeBuy;
marketingFee = marketingFeeBuy;
devFee = devFeeBuy;
totalFee = totalFeeBuy;
}
}
// Check if we are in GREED time
function inGREEDTime() public view returns (bool){
if(GREEDTriggeredAt.add(GREEDDuration) > block.timestamp){
return true;
} else {
return false;
}
}
// Check for maxTX
function checkTxLimit(address sender, uint256 amount, address recipient, bool isSell) internal view {
if (recipient != owner){
if(isSell){
require(amount <= _maxSellTxAmount || isTxLimitExempt[sender] || isTxLimitExempt[recipient], "TX Limit Exceeded");
} else {
require(amount <= _maxBuyTxAmount || isTxLimitExempt[sender] || isTxLimitExempt[recipient], "TX Limit Exceeded");
}
}
}
// Check buy cooldown
function checkBuyCooldown(address sender, address recipient) internal {
if (sender == pair &&
buyCooldownEnabled &&
!isTimelockExempt[recipient]) {
require(cooldownTimer[recipient] < block.timestamp,"Please wait between two buys");
cooldownTimer[recipient] = block.timestamp + cooldownTimerInterval;
}
}
// Check maxWallet
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
if (!authorizations[sender] && recipient != owner && recipient != address(this) && recipient != address(DEAD) && recipient != pair && recipient != marketingFeeReceiver && recipient != autoLiquidityReceiver && recipient != devFeeReceiver){
uint256 heldTokens = balanceOf(recipient);
require((heldTokens + amount) <= _maxWalletToken,"Total Holding is currently limited, you can not buy that much.");
}
}
// Check if sender is not feeExempt
function shouldTakeFee(address sender) internal view returns (bool) {
return !isFeeExempt[sender];
}
// Get total fee's or multiplication of fees
function getTotalFee(bool selling) public view returns (uint256) {
if(launchedAt + deadBlocks >= block.number){ return feeDenominator.sub(1); }
if(selling && buybackMultiplierTriggeredAt.add(buybackMultiplierLength) > block.timestamp){ return getMultipliedFee(); }
return totalFee;
}
// Get a multiplied fee when buybackMultiplier is active
function getMultipliedFee() public view returns (uint256) {
uint256 remainingTime = buybackMultiplierTriggeredAt.add(buybackMultiplierLength).sub(block.timestamp);
uint256 feeIncrease = totalFee.mul(buybackMultiplierNumerator).div(buybackMultiplierDenominator).sub(totalFee);
return totalFee.add(feeIncrease.mul(remainingTime).div(buybackMultiplierLength));
}
// Take the normal total Fee or the GREED Fee
function takeFee(address sender, uint256 amount, bool isSell, bool GREEDMode) internal returns (uint256) {
uint256 feeAmount;
// Check if we are GREEDd
if (GREEDMode){
if(isSell){
// We are selling so up the selling tax to 1.5x
feeAmount = amount.mul(totalFee).mul(3).div(2).div(feeDenominator);
} else {
// We are buying so cut our taxes in half
feeAmount = amount.mul(totalFee).div(2).div(feeDenominator);
}
} else {
feeAmount = amount.mul(totalFee).div(feeDenominator);
}
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
return amount.sub(feeAmount);
}
// Check if we should sell tokens
function shouldSwapBack() internal view returns (bool) {
return msg.sender != pair
&& !inSwap
&& swapEnabled
&& _balances[address(this)] >= swapThreshold;
}
// Enable GREED
function enableGREED(uint256 _seconds) public authorized {
GREEDTriggeredAt = block.timestamp;
GREEDDuration = _seconds;
}
// Disable the GREED mode
function disableGREED() external authorized {
GREEDTriggeredAt = 0;
}
// Enable/disable cooldown between trades
function cooldownEnabled(bool _status, uint8 _interval) public authorized {
buyCooldownEnabled = _status;
cooldownTimerInterval = _interval;
}
// Sends/return wallet from Hotel California mode an address
function HotelCaliforniamodeaddress(address _address, bool _value) public authorized{
isHotelCaliforniamode[_address] = _value;
}
// Main swapback to sell tokens for WCRO
function swapBack() internal swapping {
uint256 dynamicLiquidityFee = isOverLiquified(targetLiquidity, targetLiquidityDenominator) ? 0 : liquidityFee;
uint256 amountToLiquify = swapThreshold.mul(dynamicLiquidityFee).div(totalFee).div(2);
uint256 amountToSwap = swapThreshold.sub(amountToLiquify);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = WCRO;
uint256 balanceBefore = address(this).balance;
router.swapExactTokensForETHSupportingFeeOnTransferTokens(
amountToSwap,
0,
path,
address(this),
block.timestamp
);
uint256 amountCRO = address(this).balance.sub(balanceBefore);
uint256 totalCROFee = totalFee.sub(dynamicLiquidityFee.div(2));
uint256 amountCROLiquidity = amountCRO.mul(dynamicLiquidityFee).div(totalCROFee).div(2);
uint256 amountCROReflection = amountCRO.mul(reflectionFee).div(totalCROFee);
uint256 amountCROMarketing = amountCRO.mul(marketingFee).div(totalCROFee);
uint256 amountCRODev = amountCRO.mul(devFee).div(totalCROFee);
try distributor.deposit{value: amountCROReflection}() {} catch {}
(bool successMarketing, /* bytes memory data */) = payable(marketingFeeReceiver).call{value: amountCROMarketing, gas: 30000}("");
(bool successDev, /* bytes memory data */) = payable(devFeeReceiver).call{value: amountCRODev, gas: 30000}("");
require(successMarketing, "marketing receiver rejected ETH transfer");
require(successDev, "dev receiver rejected ETH transfer");
if(amountToLiquify > 0){
router.addLiquidityETH{value: amountCROLiquidity}(
address(this),
amountToLiquify,
0,
0,
autoLiquidityReceiver,
block.timestamp
);
emit AutoLiquify(amountCROLiquidity, amountToLiquify);
}
}
// Check if autoBuyback is enabled
function shouldAutoBuyback() internal view returns (bool) {
return msg.sender != pair
&& !inSwap
&& autoBuybackEnabled
&& autoBuybackBlockLast + autoBuybackBlockPeriod <= block.number
&& address(this).balance >= autoBuybackAmount;
}
// Trigger a manual buyback
function triggerManualBuyback(uint256 amount, bool triggerBuybackMultiplier) external authorized {
uint256 amountWithDecimals = amount * (10 ** 18);
uint256 amountToBuy = amountWithDecimals.div(100);
buyTokens(amountToBuy, DEAD);
if(triggerBuybackMultiplier){
buybackMultiplierTriggeredAt = block.timestamp;
emit BuybackMultiplierActive(buybackMultiplierLength);
}
}
// Stop the buyback Multiplier
function clearBuybackMultiplier() external authorized {
buybackMultiplierTriggeredAt = 0;
}
// Trigger an autobuyback
function triggerAutoBuyback() internal {
buyTokens(autoBuybackAmount, DEAD);
if(autoBuybackMultiplier){
buybackMultiplierTriggeredAt = block.timestamp;
emit BuybackMultiplierActive(buybackMultiplierLength);
}
autoBuybackBlockLast = block.number;
autoBuybackAccumulator = autoBuybackAccumulator.add(autoBuybackAmount);
if(autoBuybackAccumulator > autoBuybackCap){ autoBuybackEnabled = false; }
}
// Buy amount of tokens with CRO from the contract
function buyTokens(uint256 amount, address to) internal swapping {
address[] memory path = new address[](2);
path[0] = WCRO;
path[1] = address(this);
router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: amount}(
0,
path,
to,
block.timestamp
);
}
// Set autobuyback settings
function setAutoBuybackSettings(bool _enabled, uint256 _cap, uint256 _amount, uint256 _period, bool _autoBuybackMultiplier) external authorized {
autoBuybackEnabled = _enabled;
autoBuybackCap = _cap;
autoBuybackAccumulator = 0;
autoBuybackAmount = _amount;
autoBuybackBlockPeriod = _period;
autoBuybackBlockLast = block.number;
autoBuybackMultiplier = _autoBuybackMultiplier;
}
// Set buybackmultiplier settings
function setBuybackMultiplierSettings(uint256 numerator, uint256 denominator, uint256 length) external authorized {
require(numerator / denominator <= 2 && numerator > denominator);
buybackMultiplierNumerator = numerator;
buybackMultiplierDenominator = denominator;
buybackMultiplierLength = length;
}
// Check when the token is launched
function launched() internal view returns (bool) {
return launchedAt != 0;
}
// Set the launchedAt to token launch
function launch() internal {
launchedAt = block.number;
}
// Set max buy TX
function setBuyTxLimitInPercent(uint256 maxBuyTxPercent) external authorized {
_maxBuyTxAmount = _totalSupply.mul(maxBuyTxPercent).div(10000);
}
// Set max sell TX
function setSellTxLimitInPercent(uint256 maxSellTxPercent) external authorized {
_maxSellTxAmount = _totalSupply.mul(maxSellTxPercent).div(10000);
}
// Exempt from dividend
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, _balances[holder]);
}
}
// Exempt from fee
function setIsFeeExempt(address holder, bool exempt) external authorized {
isFeeExempt[holder] = exempt;
}
// Exempt from max TX
function setIsTxLimitExempt(address holder, bool exempt) external authorized {
isTxLimitExempt[holder] = exempt;
}
// Exempt from buy CoolDown
function setIsTimelockExempt(address holder, bool exempt) external authorized {
isTimelockExempt[holder] = exempt;
}
// Set our buy fees
function setBuyFees(uint256 _liquidityFeeBuy, uint256 _buybackFeeBuy, uint256 _reflectionFeeBuy, uint256 _marketingFeeBuy, uint256 _devFeeBuy, uint256 _feeDenominator) external authorized {
liquidityFeeBuy = _liquidityFeeBuy;
buybackFeeBuy = _buybackFeeBuy;
reflectionFeeBuy = _reflectionFeeBuy;
marketingFeeBuy = _marketingFeeBuy;
devFeeBuy = _devFeeBuy;
totalFeeBuy = _liquidityFeeBuy.add(_buybackFeeBuy).add(_reflectionFeeBuy).add(_marketingFeeBuy).add(_devFeeBuy);
feeDenominator = _feeDenominator;
}
// Set our sell fees
function setSellFees(uint256 _liquidityFeeSell, uint256 _buybackFeeSell, uint256 _reflectionFeeSell, uint256 _marketingFeeSell, uint256 _devFeeSell, uint256 _feeDenominator) external authorized {
liquidityFeeSell = _liquidityFeeSell;
buybackFeeSell = _buybackFeeSell;
reflectionFeeSell = _reflectionFeeSell;
marketingFeeSell = _marketingFeeSell;
devFeeSell = _devFeeSell;
totalFeeSell = _liquidityFeeSell.add(_buybackFeeSell).add(_reflectionFeeSell).add(_marketingFeeSell).add(_devFeeSell);
feeDenominator = _feeDenominator;
}
// Set the reward token address
function setRewardtoken(address _rwrdtoken) external authorized {
RWRD = _rwrdtoken;
}
// Set the development receiver
function setDevFeeReceiver(address _devFeeReceiver) external authorized {
devFeeReceiver = _devFeeReceiver;
}
// Set the marketing receiver
function setMarketingFeeReceiver(address _marketingFeeReceiver) external authorized {
marketingFeeReceiver = _marketingFeeReceiver;
}
// Set the liquidity receivers
function setLPFeeReceiver(address _autoLiquidityReceiver) external authorized {
autoLiquidityReceiver = _autoLiquidityReceiver;
}
// Set swapBack settings
function setSwapBackSettings(bool _enabled, uint256 _amount) external authorized {
swapEnabled = _enabled;
swapThreshold = _totalSupply * _amount / 10000;
}
// Set target liquidity
function setTargetLiquidity(uint256 _target, uint256 _denominator) external authorized {
targetLiquidity = _target;
targetLiquidityDenominator = _denominator;
}
// Send CRO to marketingwallet
function manualSend() external authorized {
uint256 contractETHBalance = address(this).balance;
payable(marketingFeeReceiver).transfer(contractETHBalance);
}
// Rescue any BEP20 token
function rescueAnyBEP20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
IBEP20(_tokenAddr).transfer(_to, _amount);
}
// Set criteria for auto distribution
function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external authorized {
distributor.setDistributionCriteria(_minPeriod, _minDistribution);
}
// Let people claim their dividends
function claimDividend() external {
distributor.claimDividend(msg.sender);
}
// Check how much earnings are unpaid
function getUnpaidEarnings(address shareholder) public view returns (uint256) {
return distributor.getUnpaidEarnings(shareholder);
}
// Set gas for distributor
function setDistributorSettings(uint256 gas) external authorized {
require(gas < 750000);
distributorGas = gas;
}
// Get the circulatingSupply
function getCirculatingSupply() public view returns (uint256) {
return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO));
}
// Get the liquidity backing
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
return accuracy.mul(balanceOf(pair).mul(2)).div(getCirculatingSupply());
}
// Get if we are over liquified or not
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
return getLiquidityBacking(accuracy) > target;
}
event AutoLiquify(uint256 amountCRO, uint256 amountBOG);
event BuybackMultiplierActive(uint256 duration);
}