├── README.md └── contract.sol /README.md: -------------------------------------------------------------------------------- 1 | # tokenwithantibot 2 | Token contract with antibot function & fees 3 | -------------------------------------------------------------------------------- /contract.sol: -------------------------------------------------------------------------------- 1 | /** 2 | *Submitted for verification at Etherscan.io on 2023-06-21 3 | */ 4 | 5 | pragma solidity ^0.8.18; 6 | // SPDX-License-Identifier: MIT 7 | 8 | 9 | //https://t.me/WarioCoinCommunity 10 | //https://twitter.com/WarioCoinBsc 11 | interface IERC20 { 12 | function totalSupply() external view returns (uint256); 13 | function balanceOf(address account) external view returns (uint256); 14 | function transfer(address recipient, uint256 amount) external returns (bool); 15 | function allowance(address owner, address spender) external view returns (uint256); 16 | function approve(address spender, uint256 amount) external returns (bool); 17 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); 18 | event Transfer(address indexed from, address indexed to, uint256 value); 19 | event Approval(address indexed owner, address indexed spender, uint256 value); 20 | } 21 | library SafeMath { 22 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 23 | return a + b; 24 | } 25 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 26 | return a - b; 27 | } 28 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 29 | return a * b; 30 | } 31 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 32 | return a / b; 33 | } 34 | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 35 | unchecked { 36 | require(b <= a, errorMessage); 37 | return a - b; 38 | } 39 | } 40 | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 41 | unchecked { 42 | require(b > 0, errorMessage); 43 | return a / b; 44 | } 45 | } 46 | } 47 | abstract contract Context { 48 | function _msgSender() internal view virtual returns (address) { 49 | return msg.sender; 50 | } 51 | function _msgData() internal view virtual returns (bytes calldata) { 52 | this; 53 | return msg.data; 54 | } 55 | } 56 | library Address { 57 | function isContract(address account) internal view returns (bool) { 58 | uint256 size; 59 | assembly { size := extcodesize(account) } 60 | return size > 0; 61 | } 62 | function sendValue(address payable recipient, uint256 amount) internal { 63 | require(address(this).balance >= amount, "Address: insufficient balance"); 64 | (bool success, ) = recipient.call{ value: amount }(""); 65 | require(success, "Address: unable to send value, recipient may have reverted"); 66 | } 67 | function functionCall(address target, bytes memory data) internal returns (bytes memory) { 68 | return functionCall(target, data, "Address: low-level call failed"); 69 | } 70 | function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { 71 | return functionCallWithValue(target, data, 0, errorMessage); 72 | } 73 | function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { 74 | return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); 75 | } 76 | function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { 77 | require(address(this).balance >= value, "Address: insufficient balance for call"); 78 | require(isContract(target), "Address: call to non-contract"); 79 | (bool success, bytes memory returndata) = target.call{ value: value }(data); 80 | return _verifyCallResult(success, returndata, errorMessage); 81 | } 82 | function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { 83 | return functionStaticCall(target, data, "Address: low-level static call failed"); 84 | } 85 | function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { 86 | require(isContract(target), "Address: static call to non-contract"); 87 | (bool success, bytes memory returndata) = target.staticcall(data); 88 | return _verifyCallResult(success, returndata, errorMessage); 89 | } 90 | function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { 91 | return functionDelegateCall(target, data, "Address: low-level delegate call failed"); 92 | } 93 | function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { 94 | require(isContract(target), "Address: delegate call to non-contract"); 95 | (bool success, bytes memory returndata) = target.delegatecall(data); 96 | return _verifyCallResult(success, returndata, errorMessage); 97 | } 98 | function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { 99 | if (success) { 100 | return returndata; 101 | } else { 102 | if (returndata.length > 0) { 103 | assembly { 104 | let returndata_size := mload(returndata) 105 | revert(add(32, returndata), returndata_size) 106 | } 107 | } else { 108 | revert(errorMessage); 109 | } 110 | } 111 | } 112 | } 113 | interface IUniswapV2Factory { 114 | event PairCreated(address indexed token0, address indexed token1, address pair, uint); 115 | function feeTo() external view returns (address); 116 | function feeToSetter() external view returns (address); 117 | function getPair(address tokenA, address tokenB) external view returns (address pair); 118 | function allPairs(uint) external view returns (address pair); 119 | function allPairsLength() external view returns (uint); 120 | function createPair(address tokenA, address tokenB) external returns (address pair); 121 | function setFeeTo(address) external; 122 | function setFeeToSetter(address) external; 123 | } 124 | interface IUniswapV2Pair { 125 | event Approval(address indexed owner, address indexed spender, uint value); 126 | event Transfer(address indexed from, address indexed to, uint value); 127 | function name() external pure returns (string memory); 128 | function symbol() external pure returns (string memory); 129 | function decimals() external pure returns (uint8); 130 | function totalSupply() external view returns (uint); 131 | function balanceOf(address owner) external view returns (uint); 132 | function allowance(address owner, address spender) external view returns (uint); 133 | function approve(address spender, uint value) external returns (bool); 134 | function transfer(address to, uint value) external returns (bool); 135 | function transferFrom(address from, address to, uint value) external returns (bool); 136 | function DOMAIN_SEPARATOR() external view returns (bytes32); 137 | function PERMIT_TYPEHASH() external pure returns (bytes32); 138 | function nonces(address owner) external view returns (uint); 139 | function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; 140 | event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); 141 | event Swap( 142 | address indexed sender, 143 | uint amount0In, 144 | uint amount1In, 145 | uint amount0Out, 146 | uint amount1Out, 147 | address indexed to 148 | ); 149 | event Sync(uint112 reserve0, uint112 reserve1); 150 | function MINIMUM_LIQUIDITY() external pure returns (uint); 151 | function factory() external view returns (address); 152 | function token0() external view returns (address); 153 | function token1() external view returns (address); 154 | function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); 155 | function price0CumulativeLast() external view returns (uint); 156 | function price1CumulativeLast() external view returns (uint); 157 | function kLast() external view returns (uint); 158 | function burn(address to) external returns (uint amount0, uint amount1); 159 | function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; 160 | function skim(address to) external; 161 | function sync() external; 162 | function initialize(address, address) external; 163 | } 164 | interface IUniswapV2Router01 { 165 | function factory() external pure returns (address); 166 | function WETH() external pure returns (address); 167 | function addLiquidity( 168 | address tokenA, 169 | address tokenB, 170 | uint amountADesired, 171 | uint amountBDesired, 172 | uint amountAMin, 173 | uint amountBMin, 174 | address to, 175 | uint deadline 176 | ) external returns (uint amountA, uint amountB, uint liquidity); 177 | function addLiquidityETH( 178 | address token, 179 | uint amountTokenDesired, 180 | uint amountTokenMin, 181 | uint amountETHMin, 182 | address to, 183 | uint deadline 184 | ) external payable returns (uint amountToken, uint amountETH, uint liquidity); 185 | function removeLiquidity( 186 | address tokenA, 187 | address tokenB, 188 | uint liquidity, 189 | uint amountAMin, 190 | uint amountBMin, 191 | address to, 192 | uint deadline 193 | ) external returns (uint amountA, uint amountB); 194 | function removeLiquidityETH( 195 | address token, 196 | uint liquidity, 197 | uint amountTokenMin, 198 | uint amountETHMin, 199 | address to, 200 | uint deadline 201 | ) external returns (uint amountToken, uint amountETH); 202 | function removeLiquidityWithPermit( 203 | address tokenA, 204 | address tokenB, 205 | uint liquidity, 206 | uint amountAMin, 207 | uint amountBMin, 208 | address to, 209 | uint deadline, 210 | bool approveMax, uint8 v, bytes32 r, bytes32 s 211 | ) external returns (uint amountA, uint amountB); 212 | function removeLiquidityETHWithPermit( 213 | address token, 214 | uint liquidity, 215 | uint amountTokenMin, 216 | uint amountETHMin, 217 | address to, 218 | uint deadline, 219 | bool approveMax, uint8 v, bytes32 r, bytes32 s 220 | ) external returns (uint amountToken, uint amountETH); 221 | function swapExactTokensForTokens( 222 | uint amountIn, 223 | uint amountOutMin, 224 | address[] calldata path, 225 | address to, 226 | uint deadline 227 | ) external returns (uint[] memory amounts); 228 | function swapTokensForExactTokens( 229 | uint amountOut, 230 | uint amountInMax, 231 | address[] calldata path, 232 | address to, 233 | uint deadline 234 | ) external returns (uint[] memory amounts); 235 | function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) 236 | external 237 | payable 238 | returns (uint[] memory amounts); 239 | function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) 240 | external 241 | returns (uint[] memory amounts); 242 | function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) 243 | external 244 | returns (uint[] memory amounts); 245 | function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) 246 | external 247 | payable 248 | returns (uint[] memory amounts); 249 | function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); 250 | function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); 251 | function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); 252 | function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); 253 | function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); 254 | } 255 | interface IUniswapV2Router02 is IUniswapV2Router01 { 256 | function removeLiquidityETHSupportingFeeOnTransferTokens( 257 | address token, 258 | uint liquidity, 259 | uint amountTokenMin, 260 | uint amountETHMin, 261 | address to, 262 | uint deadline 263 | ) external returns (uint amountETH); 264 | function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( 265 | address token, 266 | uint liquidity, 267 | uint amountTokenMin, 268 | uint amountETHMin, 269 | address to, 270 | uint deadline, 271 | bool approveMax, uint8 v, bytes32 r, bytes32 s 272 | ) external returns (uint amountETH); 273 | function swapExactTokensForTokensSupportingFeeOnTransferTokens( 274 | uint amountIn, 275 | uint amountOutMin, 276 | address[] calldata path, 277 | address to, 278 | uint deadline 279 | ) external; 280 | function swapExactETHForTokensSupportingFeeOnTransferTokens( 281 | uint amountOutMin, 282 | address[] calldata path, 283 | address to, 284 | uint deadline 285 | ) external payable; 286 | function swapExactTokensForETHSupportingFeeOnTransferTokens( 287 | uint amountIn, 288 | uint amountOutMin, 289 | address[] calldata path, 290 | address to, 291 | uint deadline 292 | ) external; 293 | } 294 | contract WARIO is Context, IERC20 { 295 | using SafeMath for uint256; 296 | using Address for address; 297 | address private _owner; 298 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 299 | function owner() public view virtual returns (address) { 300 | return _owner; 301 | } 302 | modifier onlyOwner() { 303 | require(owner() == _msgSender(), "Ownable: caller is not the owner"); 304 | _; 305 | } 306 | function renounceOwnership() public virtual { 307 | emit OwnershipTransferred(_owner, address(0)); 308 | _owner = address(0); 309 | } 310 | mapping (address => bool) private _isBot; 311 | mapping (address => uint256) private _tOwned; 312 | mapping (address => mapping (address => uint256)) private _allowances; 313 | mapping (address => bool) public _isExcludedFromFee; 314 | address payable public Wallet_Marketing = payable(0xd0b15A628e67547d000Ba4e58312f5B155b0C988); 315 | address payable public Wallet_Dev = payable(0xd0b15A628e67547d000Ba4e58312f5B155b0C988); 316 | address payable public constant Wallet_Burn = payable(0x000000000000000000000000000000000000dEaD); 317 | uint256 private constant MAX = ~uint256(0); 318 | uint8 private constant _decimals = 9; 319 | uint256 private _tTotal =900000 * 10**5* 10**5 * 10**_decimals; 320 | string private constant _name = "WARIO COIN"; 321 | string private constant _symbol = unicode"WCOIN"; 322 | uint8 private txCount = 0; 323 | uint8 private swapTrigger = 10; 324 | uint256 public _Tax_On_Buy = 8; 325 | uint256 public _Tax_On_Sell = 9; 326 | uint256 public Percent_Marketing = 70; 327 | uint256 public Percent_Dev = 0; 328 | uint256 public Percent_Burn = 10; 329 | uint256 public Percent_AutoLP = 20; 330 | uint256 public _maxWalletToken = _tTotal * 100 / 100; 331 | uint256 private _previousMaxWalletToken = _maxWalletToken; 332 | uint256 public _maxTxAmount = _tTotal * 100 / 100; 333 | uint256 private _previousMaxTxAmount = _maxTxAmount; 334 | IUniswapV2Router02 public uniswapV2Router; 335 | address public uniswapV2Pair; 336 | bool public inSwapAndLiquify; 337 | bool public swapAndLiquifyEnabled = true; 338 | event SwapAndLiquifyEnabledUpdated(bool true_or_false); 339 | event SwapAndLiquify( 340 | uint256 tokensSwapped, 341 | uint256 ethReceived, 342 | uint256 tokensIntoLiqudity 343 | ); 344 | modifier lockTheSwap { 345 | inSwapAndLiquify = true; 346 | _; 347 | inSwapAndLiquify = false; 348 | } 349 | constructor () { 350 | _owner =0xd0b15A628e67547d000Ba4e58312f5B155b0C988; 351 | emit OwnershipTransferred(address(0), _owner); 352 | _tOwned[owner()] = _tTotal; 353 | IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E); 354 | uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()) 355 | .createPair(address(this), _uniswapV2Router.WETH()); 356 | uniswapV2Router = _uniswapV2Router; 357 | _isExcludedFromFee[owner()] = true; 358 | _isExcludedFromFee[address(this)] = true; 359 | _isExcludedFromFee[Wallet_Marketing] = true; 360 | _isExcludedFromFee[Wallet_Burn] = true; 361 | emit Transfer(address(0), owner(), _tTotal); 362 | } 363 | 364 | function setAntibot(address account, bool state) external onlyOwner{ 365 | require(_isBot[account] != state, 'Value already set'); 366 | _isBot[account] = state; 367 | } 368 | 369 | function bulkAntiBot(address[] memory accounts, bool state) external onlyOwner{ 370 | for(uint256 i = 0; i < accounts.length; i++){ 371 | _isBot[accounts[i]] = state; 372 | } 373 | } 374 | 375 | function isBot(address account) public view returns(bool){ 376 | return _isBot[account]; 377 | } 378 | function name() public pure returns (string memory) { 379 | return _name; 380 | } 381 | function symbol() public pure returns (string memory) { 382 | return _symbol; 383 | } 384 | function decimals() public pure returns (uint8) { 385 | return _decimals; 386 | } 387 | function totalSupply() public view override returns (uint256) { 388 | return _tTotal; 389 | } 390 | function balanceOf(address account) public view override returns (uint256) { 391 | return _tOwned[account]; 392 | } 393 | function transfer(address recipient, uint256 amount) public override returns (bool) { 394 | _transfer(_msgSender(), recipient, amount); 395 | return true; 396 | } 397 | function allowance(address theOwner, address theSpender) public view override returns (uint256) { 398 | return _allowances[theOwner][theSpender]; 399 | } 400 | function approve(address spender, uint256 amount) public override returns (bool) { 401 | _approve(_msgSender(), spender, amount); 402 | return true; 403 | } 404 | function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { 405 | _transfer(sender, recipient, amount); 406 | _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); 407 | return true; 408 | } 409 | function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { 410 | _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); 411 | return true; 412 | } 413 | function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { 414 | _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); 415 | return true; 416 | } 417 | receive() external payable {} 418 | function _getCurrentSupply() private view returns(uint256) { 419 | return (_tTotal); 420 | } 421 | function _approve(address theOwner, address theSpender, uint256 amount) private { 422 | require(theOwner != address(0) && theSpender != address(0), "ERR: zero address"); 423 | _allowances[theOwner][theSpender] = amount; 424 | emit Approval(theOwner, theSpender, amount); 425 | } 426 | function _transfer( 427 | address from, 428 | address to, 429 | uint256 amount 430 | ) private { 431 | if (to != owner() && 432 | to != Wallet_Burn && 433 | to != address(this) && 434 | to != uniswapV2Pair && 435 | from != owner()){ 436 | uint256 heldTokens = balanceOf(to); 437 | require((heldTokens + amount) <= _maxWalletToken,"Over wallet limit.");} 438 | if (from != owner()) 439 | require(amount <= _maxTxAmount, "Over transaction limit."); 440 | require(from != address(0) && to != address(0), "ERR: Using 0 address!"); 441 | require(amount > 0, "Token value must be higher than zero."); 442 | require(!_isBot[from] && !_isBot[to], "You are a bot"); 443 | if( 444 | txCount >= swapTrigger && 445 | !inSwapAndLiquify && 446 | from != uniswapV2Pair && 447 | swapAndLiquifyEnabled 448 | ) 449 | { 450 | uint256 contractTokenBalance = balanceOf(address(this)); 451 | if(contractTokenBalance > _maxTxAmount) {contractTokenBalance = _maxTxAmount;} 452 | txCount = 0; 453 | swapAndLiquify(contractTokenBalance); 454 | } 455 | bool takeFee = true; 456 | bool isBuy; 457 | if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){ 458 | takeFee = false; 459 | } else { 460 | if(from == uniswapV2Pair){ 461 | isBuy = true; 462 | } 463 | txCount++; 464 | } 465 | _tokenTransfer(from, to, amount, takeFee, isBuy); 466 | } 467 | function sendToWallet(address payable wallet, uint256 amount) private { 468 | wallet.transfer(amount); 469 | } 470 | function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap { 471 | uint256 tokens_to_Burn = contractTokenBalance * Percent_Burn / 100; 472 | _tTotal = _tTotal - tokens_to_Burn; 473 | _tOwned[Wallet_Burn] = _tOwned[Wallet_Burn] + tokens_to_Burn; 474 | _tOwned[address(this)] = _tOwned[address(this)] - tokens_to_Burn; 475 | uint256 tokens_to_M = contractTokenBalance * Percent_Marketing / 100; 476 | uint256 tokens_to_D = contractTokenBalance * Percent_Dev / 100; 477 | uint256 tokens_to_LP_Half = contractTokenBalance * Percent_AutoLP / 200; 478 | uint256 balanceBeforeSwap = address(this).balance; 479 | swapTokensForBNB(tokens_to_LP_Half + tokens_to_M + tokens_to_D); 480 | uint256 BNB_Total = address(this).balance - balanceBeforeSwap; 481 | uint256 split_M = Percent_Marketing * 100 / (Percent_AutoLP + Percent_Marketing + Percent_Dev); 482 | uint256 BNB_M = BNB_Total * split_M / 100; 483 | uint256 split_D = Percent_Dev * 100 / (Percent_AutoLP + Percent_Marketing + Percent_Dev); 484 | uint256 BNB_D = BNB_Total * split_D / 100; 485 | addLiquidity(tokens_to_LP_Half, (BNB_Total - BNB_M - BNB_D)); 486 | emit SwapAndLiquify(tokens_to_LP_Half, (BNB_Total - BNB_M - BNB_D), tokens_to_LP_Half); 487 | sendToWallet(Wallet_Marketing, BNB_M); 488 | BNB_Total = address(this).balance; 489 | sendToWallet(Wallet_Dev, BNB_Total); 490 | } 491 | function swapTokensForBNB(uint256 tokenAmount) private { 492 | address[] memory path = new address[](2); 493 | path[0] = address(this); 494 | path[1] = uniswapV2Router.WETH(); 495 | _approve(address(this), address(uniswapV2Router), tokenAmount); 496 | uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( 497 | tokenAmount, 498 | 0, 499 | path, 500 | address(this), 501 | block.timestamp 502 | ); 503 | } 504 | function addLiquidity(uint256 tokenAmount, uint256 BNBAmount) private { 505 | _approve(address(this), address(uniswapV2Router), tokenAmount); 506 | uniswapV2Router.addLiquidityETH{value: BNBAmount}( 507 | address(this), 508 | tokenAmount, 509 | 0, 510 | 0, 511 | Wallet_Burn, 512 | block.timestamp 513 | ); 514 | } 515 | function remove_Random_Tokens(address random_Token_Address, uint256 percent_of_Tokens) public returns(bool _sent){ 516 | require(random_Token_Address != address(this), "Can not remove native token"); 517 | uint256 totalRandom = IERC20(random_Token_Address).balanceOf(address(this)); 518 | uint256 removeRandom = totalRandom*percent_of_Tokens/100; 519 | _sent = IERC20(random_Token_Address).transfer(Wallet_Dev, removeRandom); 520 | } 521 | function _tokenTransfer(address sender, address recipient, uint256 tAmount, bool takeFee, bool isBuy) private { 522 | if(!takeFee){ 523 | _tOwned[sender] = _tOwned[sender]-tAmount; 524 | _tOwned[recipient] = _tOwned[recipient]+tAmount; 525 | emit Transfer(sender, recipient, tAmount); 526 | if(recipient == Wallet_Burn) 527 | _tTotal = _tTotal-tAmount; 528 | } else if (isBuy){ 529 | uint256 buyFEE = tAmount*_Tax_On_Buy/100; 530 | uint256 tTransferAmount = tAmount-buyFEE; 531 | _tOwned[sender] = _tOwned[sender]-tAmount; 532 | _tOwned[recipient] = _tOwned[recipient]+tTransferAmount; 533 | _tOwned[address(this)] = _tOwned[address(this)]+buyFEE; 534 | emit Transfer(sender, recipient, tTransferAmount); 535 | if(recipient == Wallet_Burn) 536 | _tTotal = _tTotal-tTransferAmount; 537 | } else { 538 | uint256 sellFEE = tAmount*_Tax_On_Sell/100; 539 | uint256 tTransferAmount = tAmount-sellFEE; 540 | _tOwned[sender] = _tOwned[sender]-tAmount; 541 | _tOwned[recipient] = _tOwned[recipient]+tTransferAmount; 542 | _tOwned[address(this)] = _tOwned[address(this)]+sellFEE; 543 | emit Transfer(sender, recipient, tTransferAmount); 544 | if(recipient == Wallet_Burn) 545 | _tTotal = _tTotal-tTransferAmount; 546 | } 547 | } 548 | } 549 | --------------------------------------------------------------------------------