Untitled

/*
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 = 15;
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 {}
}