Untitled

mail@pastecode.io avatar
unknown
plain_text
2 years ago
13 kB
8
Indexable
Never
/*

TSKToken a 5% Buy and 20% Sell Tax

1% is automatically added to LP and Burned

5% 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 {}

}