S Price: $0.719654 (-10.89%)

Contract Diff Checker

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;
	}
}

Please enter a contract address above to load the contract details and source code.

Context size (optional):