Contract Name:
DONOTBUYTESTING
Contract Source Code:
File 1 of 1 : DONOTBUYTESTING
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.6.12;
// ----------------------
// LIBRARIES & INTERFACES
// ----------------------
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { return 0; }
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Router Interface for Metropolis Router
interface IRouter {
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
function WETH() external pure returns (address);
function swapExactTokensForETH(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
// ----------------------
// SONIC NETWORK TOKEN CONTRACT
// ----------------------
contract DONOTBUYTESTING is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "DONOTBUYTESTING";
string private _symbol = "DNBT";
uint8 private _decimals = 18;
uint256 private constant _totalSupply = 1e6 * 10**18;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public isExcludedFromRewards;
mapping(address => bool) public isBlacklisted;
mapping(address => bool) public isAdmin;
mapping(address => bool) private isHolder;
address[] private holders;
bool public tradingEnabled = false;
bool public rewardDistributionEnabled = false;
bool private inSwapAndLiquify;
uint256 public taxFee = 10; // Default 10% tax
uint256 public liquidityFee = 5; // 5% added to liquidity
uint256 public rewardsFee = 5; // 5% to rewards wallet
uint256 public minimumTokensBeforeSwap = _totalSupply.div(10000); // 0.01% of total supply
address public rewardsWallet;
address public devWallet;
address public liquidityPair;
IRouter public router;
event RewardsDistributed(uint256 totalDistributed);
event Blacklisted(address indexed account, bool isBlacklisted);
event FeesUpdated(uint256 newFee);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address _router, address _rewardsWallet, address _devWallet) public {
router = IRouter(_router);
rewardsWallet = _rewardsWallet;
devWallet = _devWallet;
_balances[_msgSender()] = _totalSupply;
// Add deployer to holders list
isHolder[_msgSender()] = true;
holders.push(_msgSender());
emit Transfer(address(0), _msgSender(), _totalSupply);
}
// --- ERC20 Standard Functions ---
function totalSupply() public view 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) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount));
return true;
}
// Internal function to remove an address from the holders array.
function _removeHolder(address account) internal {
require(isHolder[account], "Account is not a holder");
uint256 length = holders.length;
for (uint256 i = 0; i < length; i++) {
if (holders[i] == account) {
// Swap with the last element and remove the last element.
holders[i] = holders[length - 1];
holders.pop();
isHolder[account] = false;
break;
}
}
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
// Calculate fees separately:
// Liquidity fee is kept in the contract for later liquidity addition.
uint256 liquidityAmount = amount.mul(liquidityFee).div(100);
// Rewards fee is sent to the rewards wallet.
uint256 rewardsAmount = amount.mul(rewardsFee).div(100);
// Total fee is the sum of these two fees.
uint256 totalFee = liquidityAmount.add(rewardsAmount);
// The amount the recipient receives is the original amount minus the total fees.
uint256 transferAmount = amount.sub(totalFee);
// Deduct the full amount from sender's balance.
_balances[sender] = _balances[sender].sub(amount);
// Credit the recipient with the net amount.
_balances[recipient] = _balances[recipient].add(transferAmount);
// Credit the contract with the liquidity fee (for swapAndLiquify later).
_balances[address(this)] = _balances[address(this)].add(liquidityAmount);
// Credit the rewards wallet with the rewards fee.
_balances[rewardsWallet] = _balances[rewardsWallet].add(rewardsAmount);
emit Transfer(sender, recipient, transferAmount);
emit Transfer(sender, address(this), liquidityAmount);
emit Transfer(sender, rewardsWallet, rewardsAmount);
// Update holders: remove sender if balance drops to zero.
if (_balances[sender] == 0 && isHolder[sender]) {
_removeHolder(sender);
}
// Add recipient to holders if not already present.
if (!isHolder[recipient] && _balances[recipient] > 0) {
isHolder[recipient] = true;
holders.push(recipient);
}
}
function _approve(address owner, address spender, uint256 amount) internal {
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 name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
// --- End ERC20 Functions ---
function setLiquidityPair(address _pair) external onlyOwner {
require(_pair != address(0), "Liquidity pair cannot be zero address");
liquidityPair = _pair;
}
function setTradingEnabled(bool _enabled) external onlyOwner {
tradingEnabled = _enabled;
}
function setRewardDistribution(bool _enabled) external onlyOwner {
rewardDistributionEnabled = _enabled;
}
function setExcludeFromRewards(address account, bool excluded) external onlyOwner {
isExcludedFromRewards[account] = excluded;
}
function setBlacklist(address account, bool _blacklisted) external onlyOwner {
isBlacklisted[account] = _blacklisted;
emit Blacklisted(account, _blacklisted);
}
function setTaxFee(uint256 _taxFee, uint256 _liquidityFee, uint256 _rewardsFee) external onlyOwner {
require(_taxFee <= 20, "Total fee too high");
taxFee = _taxFee;
liquidityFee = _liquidityFee;
rewardsFee = _rewardsFee;
emit FeesUpdated(_taxFee);
}
function distributeRewards() external {
require(rewardDistributionEnabled, "Reward distribution is disabled");
require(msg.sender == rewardsWallet || isAdmin[msg.sender], "Not authorized");
uint256 rewardsBalance = _balances[rewardsWallet];
require(rewardsBalance > 0, "No rewards to distribute");
for (uint256 i = 0; i < holders.length; i++) {
address holder = holders[i];
if (!isExcludedFromRewards[holder]) {
uint256 share = _balances[holder].mul(rewardsBalance).div(_totalSupply);
_balances[rewardsWallet] = _balances[rewardsWallet].sub(share);
_balances[holder] = _balances[holder].add(share);
emit Transfer(rewardsWallet, holder, share);
}
}
}
function swapAndLiquify() internal lockTheSwap {
uint256 half = _balances[address(this)].div(2);
uint256 otherHalf = _balances[address(this)].sub(half);
uint256 initialBalance = address(this).balance;
swapTokensForEth(half);
uint256 newBalance = address(this).balance.sub(initialBalance);
addLiquidity(otherHalf, newBalance);
}
function manualSwapAndLiquify(uint256 amount) external {
require(msg.sender == owner() || isAdmin[msg.sender], "Not authorized");
require(_balances[address(this)] >= amount, "Insufficient contract balance");
swapAndLiquify();
}
receive() external payable {}
function withdrawS(uint256 amount) external onlyOwner {
require(address(this).balance >= amount, "Not enough balance");
payable(msg.sender).transfer(amount);
}
function setAdmin(address account, bool _isAdmin) external onlyOwner {
require(account != address(0), "Cannot set zero address as admin");
isAdmin[account] = _isAdmin;
}
function swapTokensForEth(uint256 tokenAmount) internal {
// Generate the swap path: token -> WETH
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
// Approve the router to spend tokens from this contract
_approve(address(this), address(router), tokenAmount);
// Swap tokens for ETH
// Using 0 for amountOutMin to accept any amount (consider adjusting for slippage)
router.swapExactTokensForETH(
tokenAmount,
0,
path,
address(this),
block.timestamp + 300
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
// Approve the router to spend the tokens from this contract
_approve(address(this), address(router), tokenAmount);
// Add liquidity using the Metropolis Router's addLiquidity function.
// Using 0 for amountAMin and amountBMin to accept any amounts; adjust as needed for slippage protection.
router.addLiquidity(
address(this),
router.WETH(),
tokenAmount,
ethAmount,
0,
0,
owner(),
block.timestamp + 300
);
}
function getHolders() external view returns (address[] memory) {
return holders;
}
}