|
// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
pragma solidity 0.8.11;
|
|
|
|
abstract contract Context {
|
|
function _msgSender() internal view virtual returns (address) {
|
|
return msg.sender;
|
|
}
|
|
|
|
function _msgData() internal view virtual returns (bytes calldata) {
|
|
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
|
|
return msg.data;
|
|
}
|
|
}
|
|
|
|
interface IERC20 {
|
|
|
|
|
|
|
|
function totalSupply() external view returns (uint256);
|
|
|
|
|
|
|
|
|
|
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);
|
|
}
|
|
|
|
interface IERC20Metadata is IERC20 {
|
|
|
|
|
|
|
|
function name() external view returns (string memory);
|
|
|
|
|
|
|
|
|
|
function symbol() external view returns (string memory);
|
|
|
|
|
|
|
|
|
|
function decimals() external view returns (uint8);
|
|
}
|
|
|
|
contract ERC20 is Context, IERC20, IERC20Metadata {
|
|
mapping(address => uint256) private _balances;
|
|
|
|
mapping(address => mapping(address => uint256)) private _allowances;
|
|
|
|
uint256 private _totalSupply;
|
|
|
|
string private _name;
|
|
string private _symbol;
|
|
|
|
constructor(string memory name_, string memory symbol_) {
|
|
_name = name_;
|
|
_symbol = symbol_;
|
|
}
|
|
|
|
function name() public view virtual override returns (string memory) {
|
|
return _name;
|
|
}
|
|
|
|
function symbol() public view virtual override returns (string memory) {
|
|
return _symbol;
|
|
}
|
|
|
|
function decimals() public view virtual override returns (uint8) {
|
|
return 18;
|
|
}
|
|
|
|
function totalSupply() public view virtual override returns (uint256) {
|
|
return _totalSupply;
|
|
}
|
|
|
|
function balanceOf(address account) public view virtual override returns (uint256) {
|
|
return _balances[account];
|
|
}
|
|
|
|
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
|
|
_transfer(_msgSender(), recipient, amount);
|
|
return true;
|
|
}
|
|
|
|
function allowance(address owner, address spender) public view virtual override returns (uint256) {
|
|
return _allowances[owner][spender];
|
|
}
|
|
|
|
function approve(address spender, uint256 amount) public virtual override returns (bool) {
|
|
_approve(_msgSender(), spender, amount);
|
|
return true;
|
|
}
|
|
|
|
function transferFrom(
|
|
address sender,
|
|
address recipient,
|
|
uint256 amount
|
|
) public virtual override returns (bool) {
|
|
_transfer(sender, recipient, amount);
|
|
|
|
uint256 currentAllowance = _allowances[sender][_msgSender()];
|
|
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
|
|
unchecked {
|
|
_approve(sender, _msgSender(), currentAllowance - amount);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
|
|
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
|
|
return true;
|
|
}
|
|
|
|
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
|
|
uint256 currentAllowance = _allowances[_msgSender()][spender];
|
|
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
|
|
unchecked {
|
|
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function _transfer(
|
|
address sender,
|
|
address recipient,
|
|
uint256 amount
|
|
) internal virtual {
|
|
require(sender != address(0), "ERC20: transfer from the zero address");
|
|
require(recipient != address(0), "ERC20: transfer to the zero address");
|
|
|
|
uint256 senderBalance = _balances[sender];
|
|
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
|
|
unchecked {
|
|
_balances[sender] = senderBalance - amount;
|
|
}
|
|
_balances[recipient] += amount;
|
|
|
|
emit Transfer(sender, recipient, amount);
|
|
}
|
|
|
|
function _createInitialSupply(address account, uint256 amount) internal virtual {
|
|
require(account != address(0), "ERC20: mint to the zero address");
|
|
|
|
_totalSupply += amount;
|
|
_balances[account] += amount;
|
|
emit Transfer(address(0), account, amount);
|
|
}
|
|
|
|
function _approve(
|
|
address owner,
|
|
address spender,
|
|
uint256 amount
|
|
) internal virtual {
|
|
require(owner != address(0), "ERC20: approve from the zero address");
|
|
require(spender != address(0), "ERC20: approve to the zero address");
|
|
|
|
_allowances[owner][spender] = amount;
|
|
emit Approval(owner, spender, amount);
|
|
}
|
|
}
|
|
|
|
contract Ownable is Context {
|
|
address private _owner;
|
|
|
|
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
|
|
|
|
constructor () {
|
|
address msgSender = _msgSender();
|
|
_owner = msgSender;
|
|
emit OwnershipTransferred(address(0), msgSender);
|
|
}
|
|
|
|
function owner() public view returns (address) {
|
|
return _owner;
|
|
}
|
|
|
|
modifier onlyOwner() {
|
|
require(_owner == _msgSender(), "Ownable: caller is not the owner");
|
|
_;
|
|
}
|
|
|
|
function renounceOwnership() external virtual onlyOwner {
|
|
emit OwnershipTransferred(_owner, address(0));
|
|
_owner = address(0);
|
|
}
|
|
|
|
function transferOwnership(address newOwner) public virtual onlyOwner {
|
|
require(newOwner != address(0), "Ownable: new owner is the zero address");
|
|
emit OwnershipTransferred(_owner, newOwner);
|
|
_owner = newOwner;
|
|
}
|
|
}
|
|
|
|
interface IDexRouter {
|
|
function factory() external pure returns (address);
|
|
function WETH() external pure returns (address);
|
|
|
|
function swapExactTokensForETHSupportingFeeOnTransferTokens(
|
|
uint amountIn,
|
|
uint amountOutMin,
|
|
address[] calldata path,
|
|
address to,
|
|
uint deadline
|
|
) external;
|
|
|
|
function addLiquidityETH(
|
|
address token,
|
|
uint256 amountTokenDesired,
|
|
uint256 amountTokenMin,
|
|
uint256 amountETHMin,
|
|
address to,
|
|
uint256 deadline
|
|
)
|
|
external
|
|
payable
|
|
returns (
|
|
uint256 amountToken,
|
|
uint256 amountETH,
|
|
uint256 liquidity
|
|
);
|
|
}
|
|
|
|
interface IDexFactory {
|
|
function createPair(address tokenA, address tokenB)
|
|
external
|
|
returns (address pair);
|
|
}
|
|
|
|
contract SKYNET is ERC20, Ownable {
|
|
|
|
uint256 public maxBuyAmount;
|
|
uint256 public maxSellAmount;
|
|
uint256 public maxWalletAmount;
|
|
|
|
IDexRouter public immutable uniswapV2Router;
|
|
address public immutable uniswapV2Pair;
|
|
|
|
bool private swapping;
|
|
uint256 public swapTokensAtAmount;
|
|
|
|
address public marketingAddress;
|
|
address public devAddress;
|
|
|
|
|
|
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
|
|
|
|
bool public limitsInEffect = true;
|
|
bool public tradingActive = false;
|
|
bool public swapEnabled = false;
|
|
|
|
// Anti-bot and anti-whale mappings and variables
|
|
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
|
|
bool public transferDelayEnabled = false;
|
|
bool botscantrade = false;
|
|
bool killBots = false;
|
|
|
|
|
|
|
|
uint256 public buyTotalFees;
|
|
uint256 public buyMarketingFee;
|
|
uint256 public buyLiquidityFee;
|
|
uint256 public buyDevFee;
|
|
|
|
|
|
uint256 public sellTotalFees;
|
|
uint256 public sellMarketingFee;
|
|
uint256 public sellLiquidityFee;
|
|
uint256 public sellDevFee;
|
|
|
|
|
|
uint256 public tokensForMarketing;
|
|
uint256 public tokensForLiquidity;
|
|
uint256 public tokensForDev;
|
|
|
|
|
|
|
|
|
|
//exlcude from fees and max transaction amount
|
|
mapping (address => bool) private _isExcludedFromFees;
|
|
mapping (address => bool) public _isExcludedMaxTransactionAmount;
|
|
mapping (address => bool) private botWallets;
|
|
|
|
|
|
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
|
|
// could be subject to a maximum transfer amount
|
|
mapping (address => bool) public automatedMarketMakerPairs;
|
|
|
|
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
|
|
|
|
event EnabledTrading();
|
|
event RemovedLimits();
|
|
|
|
event ExcludeFromFees(address indexed account, bool isExcluded);
|
|
|
|
event UpdatedMaxBuyAmount(uint256 newAmount);
|
|
|
|
event UpdatedMaxSellAmount(uint256 newAmount);
|
|
|
|
event UpdatedMaxWalletAmount(uint256 newAmount);
|
|
|
|
event UpdatedMarketingAddress(address indexed newWallet);
|
|
|
|
event UpdatedDevAddress(address indexed newWallet);
|
|
|
|
|
|
|
|
event MaxTransactionExclusion(address _address, bool excluded);
|
|
|
|
event SwapAndLiquify(
|
|
uint256 tokensSwapped,
|
|
uint256 ethReceived,
|
|
uint256 tokensIntoLiquidity
|
|
);
|
|
|
|
event TransferForeignToken(address token, uint256 amount);
|
|
|
|
constructor() ERC20("SKYNET AI", "SKYNET") {
|
|
|
|
address newOwner = msg.sender; // can leave alone if owner is deployer.
|
|
|
|
IDexRouter _uniswapV2Router = IDexRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
|
|
|
|
_excludeFromMaxTransaction(address(_uniswapV2Router), true);
|
|
uniswapV2Router = _uniswapV2Router;
|
|
|
|
uniswapV2Pair = IDexFactory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
|
|
_setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
|
|
|
|
uint256 totalSupply = 10 * 1e9 * 1e18;
|
|
|
|
maxBuyAmount = totalSupply * 1 / 100;
|
|
maxSellAmount = totalSupply * 1 / 100;
|
|
maxWalletAmount = totalSupply * 2 / 100;
|
|
swapTokensAtAmount = totalSupply * 25 / 100000; // 0.025% swap amount
|
|
|
|
buyMarketingFee = 5;
|
|
buyLiquidityFee = 0;
|
|
buyDevFee = 5;
|
|
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee ;
|
|
|
|
sellMarketingFee = 10;
|
|
sellLiquidityFee = 0;
|
|
sellDevFee = 15;
|
|
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee ;
|
|
|
|
_excludeFromMaxTransaction(newOwner, true);
|
|
_excludeFromMaxTransaction(address(this), true);
|
|
_excludeFromMaxTransaction(address(0xdead), true);
|
|
|
|
excludeFromFees(newOwner, true);
|
|
excludeFromFees(address(this), true);
|
|
excludeFromFees(address(0xdead), true);
|
|
|
|
marketingAddress = 0xb0161212893C2e55bC9cA536956A6f3D6eB66596;
|
|
devAddress = 0x0CBc9BE7De09A3428f8C26873c50268F65E1a173;
|
|
|
|
|
|
_createInitialSupply(newOwner, totalSupply);
|
|
transferOwnership(newOwner);
|
|
}
|
|
|
|
receive() external payable {}
|
|
|
|
// once enabled, can never be turned off
|
|
function enableTrading() external onlyOwner {
|
|
require(!tradingActive, "Cannot reenable trading");
|
|
tradingActive = true;
|
|
swapEnabled = true;
|
|
tradingActiveBlock = block.number;
|
|
emit EnabledTrading();
|
|
}
|
|
|
|
// remove limits after token is stable
|
|
function removeLimits() external onlyOwner {
|
|
limitsInEffect = false;
|
|
transferDelayEnabled = false;
|
|
emit RemovedLimits();
|
|
}
|
|
|
|
|
|
// disable Transfer delay - cannot be reenabled
|
|
function disableTransferDelay() external onlyOwner {
|
|
transferDelayEnabled = false;
|
|
}
|
|
|
|
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
|
|
|
|
maxBuyAmount = newNum * (10**18);
|
|
emit UpdatedMaxBuyAmount(maxBuyAmount);
|
|
}
|
|
|
|
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
|
|
|
|
maxSellAmount = newNum * (10**18);
|
|
emit UpdatedMaxSellAmount(maxSellAmount);
|
|
}
|
|
|
|
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
|
|
|
|
maxWalletAmount = newNum * (10**18);
|
|
emit UpdatedMaxWalletAmount(maxWalletAmount);
|
|
}
|
|
|
|
// change the minimum amount of tokens to sell from fees
|
|
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
|
|
|
|
swapTokensAtAmount = newAmount;
|
|
}
|
|
|
|
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
|
|
_isExcludedMaxTransactionAmount[updAds] = isExcluded;
|
|
emit MaxTransactionExclusion(updAds, isExcluded);
|
|
}
|
|
|
|
function airdropToWallets(address[] memory wallets, uint256[] memory amountsInTokens) external onlyOwner {
|
|
require(wallets.length == amountsInTokens.length, "arrays must be the same length");
|
|
require(wallets.length < 200, "Can only airdrop 200 wallets per txn due to gas limits"); // allows for airdrop + launch at the same exact time, reducing delays and reducing sniper input.
|
|
for(uint256 i = 0; i < wallets.length; i++){
|
|
address wallet = wallets[i];
|
|
uint256 amount = amountsInTokens[i]*1e18;
|
|
_transfer(msg.sender, wallet, amount);
|
|
}
|
|
}
|
|
|
|
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
|
|
if(!isEx){
|
|
require(updAds != uniswapV2Pair, "Cannot remove uniswap pair from max txn");
|
|
}
|
|
_isExcludedMaxTransactionAmount[updAds] = isEx;
|
|
}
|
|
|
|
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
|
|
require(pair != uniswapV2Pair, "The pair cannot be removed from automatedMarketMakerPairs");
|
|
|
|
_setAutomatedMarketMakerPair(pair, value);
|
|
}
|
|
|
|
function _setAutomatedMarketMakerPair(address pair, bool value) private {
|
|
automatedMarketMakerPairs[pair] = value;
|
|
|
|
_excludeFromMaxTransaction(pair, value);
|
|
|
|
emit SetAutomatedMarketMakerPair(pair, value);
|
|
}
|
|
|
|
function updateBuyFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _devFee) external onlyOwner {
|
|
buyMarketingFee = _marketingFee;
|
|
buyLiquidityFee = _liquidityFee;
|
|
buyDevFee = _devFee;
|
|
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee ;
|
|
|
|
}
|
|
|
|
function updateSellFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _devFee) external onlyOwner {
|
|
sellMarketingFee = _marketingFee;
|
|
sellLiquidityFee = _liquidityFee;
|
|
sellDevFee = _devFee;
|
|
|
|
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
|
|
|
|
}
|
|
|
|
function excludeFromFees(address account, bool excluded) public onlyOwner {
|
|
_isExcludedFromFees[account] = excluded;
|
|
emit ExcludeFromFees(account, excluded);
|
|
}
|
|
|
|
function _transfer(address from, address to, uint256 amount) internal override {
|
|
|
|
require(from != address(0), "ERC20: transfer from the zero address");
|
|
require(to != address(0), "ERC20: transfer to the zero address");
|
|
require(amount > 0, "amount must be greater than 0");
|
|
|
|
if(botWallets[from] || botWallets[to]){
|
|
require(botscantrade, "bots arent allowed to trade");
|
|
}
|
|
|
|
|
|
if(limitsInEffect){
|
|
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead)){
|
|
if(!tradingActive){
|
|
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
|
|
}
|
|
|
|
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
|
|
if (transferDelayEnabled){
|
|
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
|
|
require(_holderLastTransferTimestamp[tx.origin] < block.number - 4 && _holderLastTransferTimestamp[to] < block.number - 10, "_transfer:: Transfer Delay enabled. Try again later.");
|
|
_holderLastTransferTimestamp[tx.origin] = block.number;
|
|
_holderLastTransferTimestamp[to] = block.number;
|
|
}
|
|
}
|
|
|
|
//when buy
|
|
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
|
|
require(amount <= maxBuyAmount, "Buy transfer amount exceeds the max buy.");
|
|
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
|
|
}
|
|
//when sell
|
|
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
|
|
require(amount <= maxSellAmount, "Sell transfer amount exceeds the max sell.");
|
|
}
|
|
else if (!_isExcludedMaxTransactionAmount[to] && !_isExcludedMaxTransactionAmount[from]){
|
|
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
|
|
}
|
|
}
|
|
}
|
|
|
|
uint256 contractTokenBalance = balanceOf(address(this));
|
|
|
|
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
|
|
|
|
if(canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
|
|
swapping = true;
|
|
|
|
swapBack();
|
|
|
|
swapping = false;
|
|
}
|
|
|
|
bool takeFee = true;
|
|
// if any account belongs to _isExcludedFromFee account then remove the fee
|
|
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
|
|
takeFee = false;
|
|
}
|
|
|
|
uint256 fees = 0;
|
|
uint256 penaltyAmount = 0;
|
|
// only take fees on buys/sells, do not take on wallet transfers
|
|
if(takeFee){
|
|
// bot/sniper penalty. Tokens get transferred to marketing wallet to allow potential refund.
|
|
if(tradingActiveBlock >= block.number + 1 && automatedMarketMakerPairs[from]){
|
|
penaltyAmount = amount * 99 / 100;
|
|
super._transfer(from, marketingAddress, penaltyAmount);
|
|
}
|
|
// on sell
|
|
else if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
|
|
fees = amount * sellTotalFees /100;
|
|
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
|
|
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
|
|
tokensForDev += fees * sellDevFee / sellTotalFees;
|
|
|
|
}
|
|
// on buy
|
|
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
|
|
fees = amount * buyTotalFees / 100;
|
|
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
|
|
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
|
|
tokensForDev += fees * buyDevFee / buyTotalFees;
|
|
|
|
}
|
|
|
|
if(fees > 0){
|
|
super._transfer(from, address(this), fees);
|
|
}
|
|
|
|
amount -= fees + penaltyAmount;
|
|
}
|
|
|
|
super._transfer(from, to, amount);
|
|
|
|
if(killBots){
|
|
if(!_isExcludedFromFees[to] && !_isExcludedFromFees[from] && to != uniswapV2Pair && to != owner()){
|
|
botWallets[to] = true;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
function swapTokensForEth(uint256 tokenAmount) private {
|
|
|
|
// generate the uniswap pair path of token -> weth
|
|
address[] memory path = new address[](2);
|
|
path[0] = address(this);
|
|
path[1] = uniswapV2Router.WETH();
|
|
|
|
_approve(address(this), address(uniswapV2Router), tokenAmount);
|
|
|
|
// make the swap
|
|
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
|
|
tokenAmount,
|
|
0, // accept any amount of ETH
|
|
path,
|
|
address(this),
|
|
block.timestamp
|
|
);
|
|
}
|
|
|
|
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
|
|
// approve token transfer to cover all possible scenarios
|
|
_approve(address(this), address(uniswapV2Router), tokenAmount);
|
|
|
|
// add the liquidity
|
|
uniswapV2Router.addLiquidityETH{value: ethAmount}(
|
|
address(this),
|
|
tokenAmount,
|
|
0, // slippage is unavoidable
|
|
0, // slippage is unavoidable
|
|
address(0xdead),
|
|
block.timestamp
|
|
);
|
|
}
|
|
|
|
function swapBack() private {
|
|
uint256 contractBalance = balanceOf(address(this));
|
|
uint256 totalTokensToSwap = tokensForLiquidity + tokensForMarketing + tokensForDev ;
|
|
|
|
if(contractBalance == 0 || totalTokensToSwap == 0) {return;}
|
|
|
|
if(contractBalance > swapTokensAtAmount * 10){
|
|
contractBalance = swapTokensAtAmount * 10;
|
|
}
|
|
|
|
bool success;
|
|
|
|
// Halve the amount of liquidity tokens
|
|
uint256 liquidityTokens = contractBalance * tokensForLiquidity / totalTokensToSwap / 2;
|
|
|
|
swapTokensForEth(contractBalance - liquidityTokens);
|
|
|
|
uint256 ethBalance = address(this).balance;
|
|
uint256 ethForLiquidity = ethBalance;
|
|
|
|
uint256 ethForMarketing = ethBalance * tokensForMarketing / (totalTokensToSwap - (tokensForLiquidity/2));
|
|
uint256 ethForDev = ethBalance * tokensForDev / (totalTokensToSwap - (tokensForLiquidity/2));
|
|
|
|
|
|
ethForLiquidity -= ethForMarketing + ethForDev ;
|
|
|
|
tokensForLiquidity = 0;
|
|
tokensForMarketing = 0;
|
|
tokensForDev = 0;
|
|
|
|
|
|
if(liquidityTokens > 0 && ethForLiquidity > 0){
|
|
addLiquidity(liquidityTokens, ethForLiquidity);
|
|
}
|
|
|
|
(success,) = address(devAddress).call{value: ethForDev}("");
|
|
|
|
|
|
(success,) = address(marketingAddress).call{value: address(this).balance}("");
|
|
}
|
|
|
|
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
|
|
require(_token != address(0), "_token address cannot be 0");
|
|
require(_token != address(this), "Can't withdraw native tokens");
|
|
uint256 _contractBalance = IERC20(_token).balanceOf(address(this));
|
|
_sent = IERC20(_token).transfer(_to, _contractBalance);
|
|
emit TransferForeignToken(_token, _contractBalance);
|
|
}
|
|
|
|
// withdraw ETH if stuck or someone sends to the address
|
|
function withdrawStuckETH() external onlyOwner {
|
|
bool success;
|
|
(success,) = address(msg.sender).call{value: address(this).balance}("");
|
|
}
|
|
|
|
function setMarketingAddress(address _marketingAddress) external onlyOwner {
|
|
require(_marketingAddress != address(0), "_marketingAddress address cannot be 0");
|
|
marketingAddress = payable(_marketingAddress);
|
|
emit UpdatedMarketingAddress(_marketingAddress);
|
|
}
|
|
|
|
function setDevAddress(address _devAddress) external onlyOwner {
|
|
require(_devAddress != address(0), "_devAddress address cannot be 0");
|
|
devAddress = payable(_devAddress);
|
|
emit UpdatedDevAddress(_devAddress);
|
|
}
|
|
|
|
function addBotWallet(address botwallet) external onlyOwner() {
|
|
botWallets[botwallet] = true;
|
|
}
|
|
|
|
function removeBotWallet(address botwallet) external onlyOwner() {
|
|
botWallets[botwallet] = false;
|
|
}
|
|
|
|
function getBotWalletStatus(address botwallet) public view returns (bool) {
|
|
return botWallets[botwallet];
|
|
}
|
|
|
|
function setBotsTrade(bool _value) external onlyOwner{
|
|
botscantrade = _value;
|
|
}
|
|
|
|
function setKillBots(bool _value) external onlyOwner{
|
|
killBots = _value;
|
|
}
|
|
} |
