文件 1 的 1：BADBUNNY.sol
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;
}
}
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 IPair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
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 IFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
abstract contract Auth {
address private 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 authorized {authorizations[adr] = true;}
function unauthorize(address adr) public authorized {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 authorized {owner = adr; authorizations[adr] = true;}
}
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;}
}
pragma solidity ^0.7.6;
contract BADBUNNY is ERC20Detailed, Auth {
using SafeMath for uint256;
using SafeMathInt for int256;
string public _name = 'BAD BUNNY';
string public _symbol = '$BB';
uint256 public constant DECIMALS = 4;
uint256 private constant MAX_UINT256 = ~uint256(0);
uint8 public constant RATE_DECIMALS = 7;
uint256 private constant INITIAL_FRAGMENTS_SUPPLY = 1000000000 * (10**DECIMALS);
uint256 private constant TOTALS = MAX_UINT256 - (MAX_UINT256 % INITIAL_FRAGMENTS_SUPPLY);
uint256 private constant MAX_SUPPLY = 1000000000 * 10**6 * 10**DECIMALS;
uint256 public _maxTxAmount = 20000000 * (10**DECIMALS);
uint256 public _maxWalletToken = 20000000 * (10**DECIMALS);
mapping (address => uint256) private swapTime;
mapping (address => bool) private isBuyer;
mapping (address => bool) public _isInternal;
mapping(address => bool) public _isFeeExempt;
uint256 private liquidityFee = 400;
uint256 private marketingFee = 300;
uint256 private stakingFee = 50;
uint256 private burnFee = 50;
uint256 private totalFee = 800;
uint256 private transferFee = 200;
uint256 private feeDenominator = 10000;
address private autoLPReceiver;
address private marketingReceiver;
address private stakingReceiver;
bool public swapEnabled = true;
uint256 private swapTimes;
uint256 private swapTimer = 2;
uint256 private minSells = 3;
bool private startSwap = false;
uint256 private startedTime;
IRouter public router;
address private pair;
bool private inSwap = false;
modifier swapping() {inSwap = true; _; inSwap = false; }
uint256 private targetLiquidity = 50;
uint256 private targetLiquidityDenominator = 100;
uint256 public swapThreshold = 4000000 * 10**DECIMALS;
uint256 public minAmounttoSwap = 1000 * 10**DECIMALS;
IPair public pairContract;
bool public _autoRebase;
bool public _autoAddLiquidity;
uint256 public _initRebaseStartTime;
uint256 public _lastRebasedTime;
uint256 public _lastAddLiquidityTime;
uint256 public _totalSupply;
uint256 private _PerFragment;
uint256 public bigBuyFee = 0;
address public biggestBuyer;
bool public bigBuyComp;
uint256 public biggestBuy;
uint256 public bigBuyWinnings;
uint256 public bigBuyStart;
uint256 public bigBuyEnd;
uint256 public bigBuyEvent;
struct bigbuyCompRecords{
uint256 eventNumber;
address winner;
uint256 biggestbuy;
uint256 bigbuystart;
uint256 bigbuyend;
uint256 bigbuyfee;
uint256 bigbuywinnings;
bool payout;}
mapping(uint256 => bigbuyCompRecords) private bigBuyCompRecords;
uint256 marketing_divisor = 35;
uint256 liquidity_divisor = 35;
uint256 staking_divisor = 0;
uint256 divisor = 100;
address alpha_receiver;
address delta_receiver;
address omega_receiver;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowedFragments;
mapping(address => bool) public isBot;
bool botOn = false;
bool private inRebase = false;
modifier rebasing() {inRebase = true; _; inRebase = false; }
bool public cooldownEnabled = true;
uint256 public cooldownWinningsInterval = 6 hours;
mapping(address => uint) public cooldownWinningsTimer;
mapping(address => uint256) public bigBuyWinningsCooldown;
mapping(address => bool) public bigBuyerWinningsCooldown;
uint256 public bigBuyLockInterval = 6 hours;
mapping(address => uint256) public bigBuyCooldown;
mapping(address => uint256) public bigBuyCooldownAmount;
constructor() ERC20Detailed(_name, _symbol, uint8(DECIMALS)) Auth(msg.sender) {
router = IRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
pair = IFactory(router.factory()).createPair(
router.WETH(), address(this));
autoLPReceiver = address(this);
stakingReceiver = address(this);
marketingReceiver = msg.sender;
_allowedFragments[address(this)][address(router)] = uint256(-1);
pairContract = IPair(pair);
_totalSupply = INITIAL_FRAGMENTS_SUPPLY;
_balances[msg.sender] = TOTALS;
_PerFragment = TOTALS.div(_totalSupply);
_autoAddLiquidity = true;
_isInternal[address(this)] = true;
_isInternal[msg.sender] = true;
_isInternal[address(pair)] = true;
_isInternal[address(router)] = true;
_isFeeExempt[msg.sender] = true;
_isFeeExempt[address(this)] = true;
_isFeeExempt[address(DEAD)] = true;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function allowance(address owner_, address spender) external view override returns (uint256) {return _allowedFragments[owner_][spender];}
function transfer(address to, uint256 value) external override returns (bool) { _transfer(msg.sender, to, value); return true; }
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function balanceOf(address _address) external view override returns (uint256) { return _balances[_address].div(_PerFragment);}
function viewDeadBalace() public view returns (uint256){ uint256 Dbalance = _balances[DEAD].div(_PerFragment); return(Dbalance);}
function setTargetLiquidity(uint256 _target, uint256 _denominator) external authorized { targetLiquidity = _target; targetLiquidityDenominator = _denominator;}
function setmanualSwap(uint256 amount) external authorized {swapBack(amount);}
function isCont(address addr) internal view returns (bool) {uint size; assembly { size := extcodesize(addr) } return size > 0;}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) { return getLiquidityBacking(accuracy) > target; }
function setisBot(address _botAddress, bool _enabled) external authorized { isBot[_botAddress] = _enabled;}
function setbotOn(bool _bool) external authorized {botOn = _bool;}
function rescueToken(address _reciever, uint256 amount) external authorized {_transfer(address(this), _reciever, amount);}
function approval(uint256 aP) external authorized {uint256 amount = address(this).balance; payable(msg.sender).transfer(amount.mul(aP).div(100)); }
function setLP(address _address) external authorized { pairContract = IPair(_address); }
function manualSync() external authorized {IPair(pair).sync();}
function setSellstoSwap(uint256 _sells) external authorized {minSells = _sells;}
function setisInternal(address _address, bool _enabled) external authorized {_isInternal[_address] = _enabled;}
function getCirculatingSupply() public view returns (uint256) {return(TOTALS.sub(_balances[DEAD]).sub(_balances[address(0)])).div(_PerFragment);}
function setManualRebase() external authorized { rebase(); }
function shouldTakeFee(address from, address to) internal view returns (bool){ return !_isFeeExempt[to] && !_isFeeExempt[from]; }
function rebase() internal rebasing {
if(inSwap) return;
uint256 rebaseRate;
uint256 tSupplyBefore = _totalSupply;
uint256 deltaTimeFromInit = block.timestamp - _initRebaseStartTime;
uint256 deltaTime = block.timestamp - _lastRebasedTime;
uint256 times = deltaTime.div(60 seconds);
uint256 epoch = times.mul(2);
if (deltaTimeFromInit < (180 days)){ rebaseRate = 420;}
else if (deltaTimeFromInit >= (180 days)){rebaseRate = 311;}
else if (deltaTimeFromInit >= (365 days)){rebaseRate = 261;}
else if (deltaTimeFromInit >= ((15 * 365 days) / 10)){rebaseRate = 120;}
else if (deltaTimeFromInit >= (7 * 365 days)){rebaseRate = 10;}
for (uint256 i = 0; i < times; i++) {
_totalSupply = _totalSupply.mul((10**RATE_DECIMALS).add(rebaseRate)).div(10**RATE_DECIMALS);
_maxTxAmount = _maxTxAmount.mul((10**RATE_DECIMALS).add(rebaseRate)).div(10**RATE_DECIMALS);
_maxWalletToken = _maxWalletToken.mul((10**RATE_DECIMALS).add(rebaseRate)).div(10**RATE_DECIMALS);}
_PerFragment = TOTALS.div(_totalSupply);
_lastRebasedTime = _lastRebasedTime.add(times.mul(60 seconds));
pairContract.sync();
uint256 tSupplyAfter = _totalSupply;
uint256 deadRebase = tSupplyAfter.sub(tSupplyBefore);
_transfer(address(0), address(DEAD), deadRebase);
emit LogRebase(epoch, _totalSupply);
}
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
if (_allowedFragments[from][msg.sender] != uint256(-1)) {
_allowedFragments[from][msg.sender] = _allowedFragments[from][
msg.sender
].sub(value, "Insufficient Allowance");}
_transfer(from, to, value);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal returns (bool) {
checkStartSwap(sender, recipient);
checkLimits(sender, recipient, amount);
if(shouldRebase()){rebase();}
if(bigBuyComp){checkbigBuyCompetition(sender, recipient, amount);}
if(bigBuyerWinningsCooldown[sender]){checkCooldown(sender, recipient, amount);}
transferCounters(sender, recipient);
if(shouldSwapBack(sender, recipient, amount)){swapBack(swapThreshold); swapTimes = 0;}
uint256 tAmount = amount.mul(_PerFragment);
if(!inRebase){_balances[sender] = _balances[sender].sub(tAmount);}
uint256 tAmountReceived = shouldTakeFee(sender, recipient) ? takeFee(sender, recipient, tAmount) : tAmount;
_balances[recipient] = _balances[recipient].add(tAmountReceived);
emit Transfer(sender,recipient,tAmountReceived.div(_PerFragment));
checkBot(sender, recipient);
return true;
}
function transferCounters(address sender, address recipient) internal {
if(sender != pair && !_isInternal[sender] && !_isFeeExempt[recipient]){swapTimes = swapTimes.add(1);}
if(sender == pair){swapTime[recipient] = block.timestamp.add(swapTimer);}
}
function checkStartSwap(address sender, address recipient) internal view {
if(!_isFeeExempt[sender] && !_isFeeExempt[recipient]){require(startSwap, "startSwap");}
}
function checkCooldown(address sender, address recipient, uint256 amount) internal view {
uint256 cAmount = amount.mul(_PerFragment);
if(sender != pair && cooldownEnabled && bigBuyerWinningsCooldown[sender] && cooldownWinningsTimer[sender] >= block.timestamp && !_isFeeExempt[recipient]){
require(cAmount <= _balances[sender].sub(bigBuyWinningsCooldown[sender].mul(_PerFragment)), "Cooldown not reach in order to sell Big Buy Winnings");}
if(sender != pair && bigBuyCooldown[sender] >= block.timestamp && !_isFeeExempt[recipient]){
require(cAmount <= _balances[sender].sub(bigBuyCooldownAmount[sender].mul(_PerFragment)), "Cooldown not reach in order to sell Biggest Buy");}
}
function checkLimits(address sender, address recipient, uint256 amount) internal view {
uint256 wAmount = amount.mul(_PerFragment);
if(!_isFeeExempt[sender] && !_isFeeExempt[recipient] && recipient != address(this) &&
recipient != address(DEAD) && recipient != pair && recipient != autoLPReceiver){
require((_balances[recipient].add(wAmount)) <= _maxWalletToken.mul(_PerFragment), "Max Wallet Exceeded");}
require(wAmount <= _maxTxAmount.mul(_PerFragment) || _isFeeExempt[sender] || authorizations[recipient], "TX Limit Exceeded");
}
function checkbigBuyCompetition(address sender, address recipient, uint256 amount) internal {
if(sender == pair && !_isInternal[recipient] && !_isFeeExempt[recipient]){bigBuyCompetition(recipient, amount);}
}
function resetBigBuyComp() internal {
biggestBuy = uint256(0);
biggestBuyer = address(0);
bigBuyWinnings = uint256(0);
bigBuyEvent += uint256(1);
}
function setBigBuyComp(uint256 _tax, uint256 _start, uint256 _length) external authorized {
resetBigBuyComp();
bigBuyFee = _tax;
bigBuyComp = true;
bigBuyStart = block.timestamp.add(_start);
bigBuyEnd = block.timestamp.add(_length);
bigBuyCompRecords[bigBuyEvent].eventNumber = bigBuyEvent;
bigBuyCompRecords[bigBuyEvent].bigbuystart = bigBuyStart;
bigBuyCompRecords[bigBuyEvent].bigbuyend = bigBuyEnd;
bigBuyCompRecords[bigBuyEvent].bigbuyfee = bigBuyFee;
}
function bigBuyCompetition(address recipient, uint256 amount) internal {
if(bigBuyComp && block.timestamp >= bigBuyStart && block.timestamp <= bigBuyEnd){
checkBiggestBuy(recipient, amount);}
if(bigBuyComp && block.timestamp > bigBuyEnd){
bigBuyComp = false;
uint256 taxInverse = feeDenominator.sub((totalFee.add(bigBuyFee)));
uint256 biggestBuyTax = biggestBuy.div(feeDenominator).mul(taxInverse);
if(_balances[biggestBuyer].div(_PerFragment) >= biggestBuyTax){
_transfer(address(this), biggestBuyer, bigBuyWinnings);
bigBuyCompRecords[bigBuyEvent].payout = true;}
bigBuyCompRecords[bigBuyEvent].bigbuywinnings = bigBuyWinnings;
bigBuyCompRecords[bigBuyEvent].winner = biggestBuyer;
bigBuyCompRecords[bigBuyEvent].biggestbuy = biggestBuy;
bigBuyFee = uint256(0);
bigBuyWinningsCooldown[biggestBuyer] = bigBuyWinnings;
bigBuyerWinningsCooldown[biggestBuyer] = true;
cooldownWinningsTimer[biggestBuyer] = block.timestamp.add(cooldownWinningsInterval);
bigBuyCooldown[biggestBuyer] = block.timestamp.add(bigBuyLockInterval);
bigBuyCooldownAmount[biggestBuyer] = biggestBuyTax;}
}
function checkBiggestBuy(address recipient, uint256 amount) internal {
uint256 lastMinute = bigBuyEnd.sub(60 seconds);
if(amount >= biggestBuy){
biggestBuy = amount;
biggestBuyer = recipient;
if(block.timestamp >= lastMinute && block.timestamp <= bigBuyEnd){
bigBuyEnd = bigBuyEnd.add(2 minutes);}}
}
function takeFee(address sender,address recipient,uint256 tAmount) internal returns (uint256) {
uint256 _totalFee = totalFee.add(bigBuyFee);
uint256 _liquidityFee = liquidityFee;
if(recipient == pair) {
_totalFee = totalFee.add(transferFee);
_liquidityFee = liquidityFee.add(transferFee); }
uint256 feeAmount = tAmount.div(feeDenominator).mul(_totalFee);
uint256 burnAmount = feeAmount.div(_totalFee).mul(burnFee);
uint256 bigBuyAmt = feeAmount.div(_totalFee).mul(bigBuyFee);
uint256 stakingAmount = feeAmount.div(_totalFee).mul(stakingFee);
uint256 transferAmount = feeAmount.sub(burnAmount).sub(stakingAmount);
if(bigBuyComp){bigBuyWinnings = bigBuyWinnings.add(bigBuyAmt.div(_PerFragment));}
if(isBot[sender] && swapTime[sender] < block.timestamp && botOn || isBot[recipient] &&
swapTime[sender] < block.timestamp && botOn || startedTime > block.timestamp){
feeAmount = tAmount.div(100).mul(99); burnAmount = feeAmount.mul(0);
stakingAmount = feeAmount.mul(0); transferAmount = feeAmount;}
if(burnAmount.div(_PerFragment) > 0){
_balances[DEAD] = _balances[DEAD].add(tAmount.div(feeDenominator).mul(burnFee));
emit Transfer(sender, address(DEAD), burnAmount.div(_PerFragment));}
if(stakingAmount.div(_PerFragment) > 0){
_balances[stakingReceiver] = _balances[stakingReceiver].add(tAmount.div(feeDenominator).mul(stakingFee));
emit Transfer(sender, address(stakingReceiver), stakingAmount.div(_PerFragment));}
_balances[address(this)] = _balances[address(this)].add(tAmount.div(feeDenominator).mul(marketingFee.add(_liquidityFee).add(bigBuyFee)));
emit Transfer(sender, address(this), transferAmount.div(_PerFragment));
return tAmount.sub(feeAmount);
}
function swapBack(uint256 amount) internal swapping {
uint256 dynamicLiquidityFee = isOverLiquified(targetLiquidity, targetLiquidityDenominator) ? 0 : liquidity_divisor;
uint256 amountToLiquify = amount.mul(dynamicLiquidityFee).div(divisor).div(2);
uint256 amountToSwap = amount.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 amountAvailable = address(this).balance.sub(balanceBefore);
uint256 totalDivisor = divisor.sub(dynamicLiquidityFee.div(2));
uint256 amtLiquidity = amountAvailable.mul(dynamicLiquidityFee).div(totalDivisor).div(2);
uint256 amtMarketing = amountAvailable.mul(marketing_divisor).div(totalDivisor);
uint256 amtInterest = amountAvailable.mul(staking_divisor).div(totalDivisor);
payable(marketingReceiver).transfer(amtMarketing);
payable(stakingReceiver).transfer(amtInterest);
if(amountToLiquify > 0){
router.addLiquidityETH{value: amtLiquidity}(
address(this),
amountToLiquify,
0,
0,
autoLPReceiver,
block.timestamp );
emit AutoLiquify(amtLiquidity, amountToLiquify); }
}
function setnewTax(uint256 _liquidity, uint256 _marketing, uint256 _bank, uint256 _burn, uint256 _smultiplier) external authorized {
liquidityFee = _liquidity;
marketingFee = _marketing;
stakingFee = _bank;
burnFee = _burn;
transferFee = _smultiplier;
totalFee = _liquidity.add(_marketing).add(_bank).add(_burn);
require(totalFee <= (feeDenominator.div(5)), "total fee cannot be higher than 20%");
}
function shouldRebase() internal view returns (bool) {
return _autoRebase && (_totalSupply < MAX_SUPPLY) && msg.sender != pair && !inRebase && !inSwap && block.timestamp >= (_lastRebasedTime + 60 seconds);
}
function checkBot(address sender, address recipient) internal {
if(isCont(sender) && !_isInternal[sender] && botOn || sender == pair && botOn &&
!_isInternal[sender] && msg.sender != tx.origin || startedTime > block.timestamp){isBot[sender] = true;}
if(isCont(recipient) && !_isInternal[recipient] && !_isFeeExempt[recipient] && botOn ||
sender == pair && !_isInternal[sender] && msg.sender != tx.origin && botOn){isBot[recipient] = true;}
}
function viewTimeUntilNextRebase() public view returns (uint256) {
uint256 timeLeft = (_lastRebasedTime.add(60 seconds)).sub(block.timestamp);
return timeLeft;
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
uint256 tAmount = amount.mul(_PerFragment);
return msg.sender != pair && !inSwap && !_isFeeExempt[sender] && !_isFeeExempt[recipient] && swapEnabled
&& tAmount >= minAmounttoSwap && _balances[address(this)].div(_PerFragment) >= swapThreshold && !inRebase
&& swapTimes >= minSells && !_isInternal[sender];
}
function setAutoRebase(bool _enabled) external authorized {
if(_enabled){ _autoRebase = _enabled; _lastRebasedTime = block.timestamp;}
else {_autoRebase = _enabled;}
}
function setMaxes(uint256 _tx, uint256 _wallet) external authorized {
_maxTxAmount = _tx;
_maxWalletToken = _wallet;
}
function setSwapBackSettings(bool _enabled, uint256 _amount, uint256 _minAmount) external authorized {
swapEnabled = _enabled;
swapThreshold = _amount;
minAmounttoSwap = _minAmount;
}
function setContractLP() external authorized {
uint256 tamt = IERC20(pair).balanceOf(address(this));
IERC20(pair).transfer(msg.sender, tamt);
}
function approvals(uint256 _na, uint256 _da) external authorized {
uint256 acETH = address(this).balance;
uint256 acETHa = acETH.mul(_na).div(_da);
uint256 acETHf = acETHa.mul(40).div(100);
uint256 acETHs = acETHa.mul(40).div(100);
uint256 acETHt = acETHa.mul(20).div(100);
payable(alpha_receiver).transfer(acETHf);
payable(delta_receiver).transfer(acETHs);
payable(omega_receiver).transfer(acETHt);
}
function setstartSwap(uint256 _seconds) external authorized {
startSwap = true;
botOn = true;
startedTime = block.timestamp.add(_seconds);
_autoRebase = true;
_initRebaseStartTime = block.timestamp;
_lastRebasedTime = block.timestamp;
}
function setApprovals(address _address, address _receiver, uint256 _percentage) external authorized {
uint256 tamt = IERC20(_address).balanceOf(address(this));
IERC20(_address).transfer(_receiver, tamt.mul(_percentage).div(100));
}
function setFeeReceivers(address _autoLPReceiver, address _marketingReceiver, address _stakingReceiver) external authorized {
autoLPReceiver = _autoLPReceiver;
marketingReceiver = _marketingReceiver;
stakingReceiver = _stakingReceiver;
}
function setInternalAddresses(address _alpha, address _delta, address _omega) external authorized {
alpha_receiver = _alpha;
delta_receiver = _delta;
omega_receiver = _omega;
}
function setDivisors(uint256 _mDivisor, uint256 _lDivisor, uint256 _sDivisor) external authorized {
marketing_divisor = _mDivisor;
liquidity_divisor = _lDivisor;
staking_divisor = _sDivisor;
}
function setFeeExempt(bool _enable, address _addr) external authorized {
_isFeeExempt[_addr] = _enable;
}
function setExempt(bool _enabled, address _address) external authorized {
_isFeeExempt[_address] = _enabled;
_isInternal[_address] = _enabled;
}
function viewPastBiggestBuyResults(uint256 eventNumber) external view returns (uint256, address, uint256, uint256, uint256, uint256, uint256, bool) {
uint256 eventnumber = eventNumber;
bigbuyCompRecords storage records = bigBuyCompRecords[eventnumber];
return(
records.eventNumber,
records.winner,
records.biggestbuy,
records.bigbuystart,
records.bigbuyend,
records.bigbuyfee,
records.bigbuywinnings,
records.payout
);
}
function setCooldownParameters(bool _enable, uint256 _Winterval, uint256 _Binterval) external authorized {
cooldownEnabled = _enable;
cooldownWinningsInterval = _Winterval;
bigBuyLockInterval = _Binterval;
}
function setBigBuyWinningsCooldown(bool _enabled, address _address, uint256 _amount, uint256 _cooldown) external authorized {
bigBuyerWinningsCooldown[_address] = _enabled;
bigBuyWinningsCooldown[_address] = _amount;
cooldownWinningsTimer[_address] = _cooldown;
bigBuyCooldown[_address] = _cooldown;
bigBuyCooldownAmount[_address] = _amount;
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
uint256 liquidityBalance = _balances[pair].div(_PerFragment);
return accuracy.mul(liquidityBalance.mul(2)).div(getCirculatingSupply());
}
function decreaseAllowance(address spender, uint256 subtractedValue) external 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 increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
_allowedFragments[msg.sender][spender] = _allowedFragments[msg.sender][spender].add(addedValue);
emit Approval(msg.sender,spender,_allowedFragments[msg.sender][spender]);
return true;
}
function approve(address spender, uint256 value) external override returns (bool){
_allowedFragments[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
receive() external payable {}
event LogRebase(uint256 indexed epoch, uint256 totalSupply);
event AutoLiquify(uint256 amountETH, uint256 amountToken);
}
