Untitled
unknown
plain_text
2 years ago
15 kB
7
Indexable
/* TSKToken a 5% Buy and 20% Sell Tax 1% is automatically added to LP and Burned 4% is used for Marketing and Development 1% Max Wallet and TX */ // SPDX-License-Identifier: Unlicensed pragma solidity ^ 0.8 .9; interface IUniswapV2Router02 { function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external; function factory() external pure returns(address); function WETH() external pure returns(address); function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns(uint256 amountToken, uint256 amountETH, uint256 liquidity); } interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns(address pair); } abstract contract Context { function _msgSender() internal view virtual returns(address) { return msg.sender; } function _msgData() internal view virtual returns(bytes calldata) { return msg.data; } } abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /* @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /* @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /* @dev Returns the address of the current owner. */ function owner() public view virtual returns(address) { return _owner; } /* @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /* @dev Leaves the contract without owner. It will not be possible to call 'onlyOwner' functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /* @dev Transfers ownership of the contract to a new account ('newOwner'). Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /* @dev Transfers ownership of the contract to a new account ('newOwner'). Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } /* @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /* @dev Emitted when 'value' tokens are moved from one account ('from') to another ('to'). Note that 'value' may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /* @dev Emitted when the allowance of a 'spender' for an 'owner' is set by a call to {approve}. 'value' is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /* @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns(uint256); /* @dev Returns the amount of tokens owned by 'account'. */ function balanceOf(address account) external view returns(uint256); /* @dev Moves 'amount' tokens from the caller's account to 'to'. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns(bool); /* @dev Returns the remaining number of tokens that 'spender' will be allowed to spend on behalf of 'owner' through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns(uint256); /* @dev Sets 'amount' as the allowance of 'spender' over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns(bool); /* @dev Moves 'amount' tokens from 'from' to 'to' using the allowance mechanism. 'amount' is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 amount) external returns(bool); } contract TSK is IERC20, Ownable { string private constant _name = "TSKToken"; string private constant _symbol = "TSK"; uint8 private constant _decimals = 9; uint256 private constant _totalSupply = 1000000000 * 10 ** 9; uint256 private _taxFeeOnBuy = 5; uint256 private _taxFeeOnSell = 20; uint256 private _liquidityFeeSplit = 5; // Denominator of fees that go to liquidity. E.g 5 means 1/5 goes to liquidity mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; mapping(address => bool) private _isExcludedFromFee; address payable private _developmentAddress = payable(0x5DA96026aFadE7aB8123A8FD96030d228Bd579db); address payable private _marketingAddress = payable(0x8cDd610Ef2D36f3415517eD313BBde55B0515B6F); address payable private _liquidityReceiver = payable(0x000000000000000000000000000000000000dEaD); IUniswapV2Router02 public uniswapV2Router; address public uniswapV2Pair; bool private tradingOpen = true; bool private inSwap = false; bool private swapEnabled = true; uint256 public _maxTxAmount = 10000000 * 10 ** 9; uint256 public _maxWalletSize = 10000000 * 10 ** 9; uint256 public _swapTokensAtAmount = 5000000 * 10 ** 9; event MaxTxAmountUpdated(uint256 _maxTxAmount); modifier lockTheSwap() { inSwap = true; _; inSwap = false; } constructor() { _balances[_msgSender()] = _totalSupply; uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH()); _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; _isExcludedFromFee[_developmentAddress] = true; _isExcludedFromFee[_marketingAddress] = true; emit Transfer(address(0), _msgSender(), _totalSupply); } function name() public pure returns(string memory) { return _name; } function symbol() public pure returns(string memory) { return _symbol; } function decimals() public pure returns(uint8) { return _decimals; } function totalSupply() public pure override returns(uint256) { return _totalSupply; } function balanceOf(address account) public view override returns(uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public override returns(bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns(uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns(bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns(bool) { uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); unchecked { _approve(sender, _msgSender(), currentAllowance - amount); } _transfer(sender, recipient, amount); return true; } // private function _approve(address owner, address spender, uint256 amount) private { 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); } function _transfer(address from, address to, uint256 amount) private { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); if (from != owner() && to != owner()) { //Trade start check if (!tradingOpen) { require(from == owner(), "TOKEN: This account cannot send tokens until trading is enabled"); } if (to != _marketingAddress && from != _marketingAddress && to != _developmentAddress && from != _developmentAddress) { require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit"); } if (to != uniswapV2Pair && to != _marketingAddress && from != _marketingAddress && to != _developmentAddress && from != _developmentAddress) { require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!"); } uint256 contractTokenBalance = balanceOf(address(this)); if (contractTokenBalance >= _maxTxAmount) { contractTokenBalance = _maxTxAmount; } bool canSwap = contractTokenBalance >= _swapTokensAtAmount; if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) { uint256 liquidityTokenFee = _liquidityFeeSplit > 0 ? contractTokenBalance / _liquidityFeeSplit : 0; swapTokensForEth(contractTokenBalance - liquidityTokenFee); if (liquidityTokenFee > 0) { _addLiquidity(_liquidityReceiver, liquidityTokenFee); } uint256 contractETHBalance = address(this).balance; if (contractETHBalance > 0) { _marketingAddress.transfer(address(this).balance); } } } //Transfer Tokens uint256 _taxFee = 0; if ( (_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) { _taxFee = 0; } else { //Set Fee for Buys if (from == uniswapV2Pair && to != address(uniswapV2Router)) { _taxFee = _taxFeeOnBuy; } //Set Fee for Sells if (to == uniswapV2Pair && from != address(uniswapV2Router)) { _taxFee = _taxFeeOnSell; } } _tokenTransfer(from, to, amount, _taxFee); } function swapTokensForEth(uint256 tokenAmount) private lockTheSwap { address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); _approve(address(this), address(uniswapV2Router), tokenAmount); uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, address(this), block.timestamp); } function _addLiquidity(address to, uint256 amount) private { _approve(address(this), address(uniswapV2Router), amount); uniswapV2Router.addLiquidityETH { value: address(this).balance }(address(this), amount, 0, 0, to, block.timestamp); } function _tokenTransfer(address sender, address recipient, uint256 amount, uint256 tax) private { uint256 tTeam = (amount * tax) / 100; uint256 tTransferAmount = amount - tTeam; _balances[sender] = _balances[sender] - amount; _balances[recipient] = _balances[recipient] + tTransferAmount; if (tTeam > 0) { _balances[address(this)] = _balances[address(this)] + tTeam; emit Transfer(sender, address(this), tTeam); } emit Transfer(sender, recipient, tTransferAmount); } // onlyOwner external function setTrading(bool _tradingOpen) external onlyOwner { tradingOpen = _tradingOpen; } function setFee(uint256 taxFeeOnBuy, uint256 taxFeeOnSell) external onlyOwner { _taxFeeOnBuy = taxFeeOnBuy; _taxFeeOnSell = taxFeeOnSell; } function setLiquidityTax(uint256 _lpFeeSplit) external onlyOwner { _liquidityFeeSplit = _lpFeeSplit; } function setLiquidityReceiver(address payable _newReceiver) external onlyOwner { _liquidityReceiver = _newReceiver; } //Set minimum tokens required to swap. function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) external onlyOwner { _swapTokensAtAmount = swapTokensAtAmount; } //Set minimum tokens required to swap. function toggleSwap(bool _swapEnabled) external onlyOwner { swapEnabled = _swapEnabled; } //Set maximum transaction function setMaxTxnAmount(uint256 maxTxAmount) external onlyOwner { _maxTxAmount = maxTxAmount; } function setMaxWalletSize(uint256 maxWalletSize) external onlyOwner { _maxWalletSize = maxWalletSize; } function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) external onlyOwner { for (uint256 i = 0; i < accounts.length; i++) { _isExcludedFromFee[accounts[i]] = excluded; } } receive() external payable {} }
Editor is loading...