PulseChain Explorer - BlockScout

Contract Address

Is Yul contract

No

Yes

Contract Name

Include nightly builds

No

Yes

Compiler

EVM Version

Optimization

No

Yes

Optimization runs

Enter the Solidity Contract Code

/*
 * ZeroTaxToken for PulseChain
 *
 * Written by: MrGreenCrypto
 * Co-Founder of CodeCraftrs.com
 * 
 * SPDX-License-Identifier: None
 */

pragma solidity 0.8.19;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function decimals() external view returns (uint8);
    function symbol() external view returns (string memory);
    function name() external view returns (string memory);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address _owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount ) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IDEXRouter {
    function factory() external pure returns (address);    
    function WPLS() external pure returns (address);
}
interface IDEXFactory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
    function getPair(address tokenA, address tokenB) external view returns (address pair);
}

contract ZeroTax is IERC20 {
    string private _name;
    string private _symbol;
    uint8 constant _decimals = 18;
    uint256 _totalSupply;

mapping(address => bool) public isExludedFromMaxWallet;
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
   
    uint256 public maxWalletInPermille = 30;
    uint256 private maxTx = 100;
    
    address public ceo;
    address public pair;
    address public router = 0x98bf93ebf5c380C0e6Ae8e192A7e2AE08edAcc02;
    address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
    address private royalty1 = 0xe6497e1F2C5418978D5fC2cD32AA23315E7a41Fb;
    address private royalty2 = 0x2E51a8222bFf11C2D1BB78E1B4a07bCEa4baCc25;

modifier onlyCEO(){
        require (msg.sender == ceo, "Only the ceo can do that");
        _;
    }

constructor(string memory name_, string memory symbol_, uint256 totalSupply_)  {
        ceo = msg.sender;
        _name = name_;
        _symbol = symbol_;
        _totalSupply = totalSupply_ * (10**_decimals);
        pair = IDEXFactory(IDEXRouter(router).factory()).createPair(IDEXRouter(router).WPLS(), address(this));

isExludedFromMaxWallet[pair] = true;
        isExludedFromMaxWallet[address(this)] = true;

_balances[ceo] = _totalSupply * 98 / 100;
        emit Transfer(address(0), ceo, _totalSupply * 98 / 100);
        _balances[royalty1] = _totalSupply/100;
        emit Transfer(address(0), royalty1, _totalSupply/100);
        _balances[royalty2] = _totalSupply/100;
        emit Transfer(address(0), royalty2, _totalSupply/100);
    }

receive() external payable {}
    function name() public view override returns (string memory) {return _name;}
    function totalSupply() public view override returns (uint256) {return _totalSupply - _balances[DEAD];}
    function decimals() public pure override returns (uint8) {return _decimals;}
    function symbol() public view override returns (string memory) {return _symbol;}
    function balanceOf(address account) public view override returns (uint256) {return _balances[account];}
    function rescueBnb(uint256 amount) external onlyCEO {(bool success,) = address(ceo).call{value: amount}("");success = true;}
    function rescueToken(address token, uint256 amount) external onlyCEO {IERC20(token).transfer(ceo, amount);}
    function allowance(address holder, address spender) public view override returns (uint256) {return _allowances[holder][spender];}
    function transfer(address recipient, uint256 amount) external override returns (bool) {return _transferFrom(msg.sender, recipient, amount);}
    function approveMax(address spender) external returns (bool) {return approve(spender, type(uint256).max);}
    
    function approve(address spender, uint256 amount) public override returns (bool) {
        require(spender != address(0), "Can't use zero address here");
        _allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        require(spender != address(0), "Can't use zero address here");
        _allowances[msg.sender][spender]  = allowance(msg.sender, spender) + addedValue;
        emit Approval(msg.sender, spender, _allowances[msg.sender][spender]);
        return true;
    }

function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        require(spender != address(0), "Can't use zero address here");
        require(allowance(msg.sender, spender) >= subtractedValue, "Can't subtract more than current allowance");
        _allowances[msg.sender][spender]  = allowance(msg.sender, spender) - subtractedValue;
        emit Approval(msg.sender, spender, _allowances[msg.sender][spender]);
        return true;
    }

function renounceOerwrship() external onlyCEO {
        ceo = address(0);
    }

function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
        checkLimits(sender, recipient, amount);
        _lowGasTransfer(sender, recipient, amount);
        return true;
    }

function checkLimits(address sender, address recipient, uint256 amount) internal view {
        if(maxWalletInPermille < 1000) {    
            if(!isExludedFromMaxWallet[recipient]) require(_balances[recipient] + amount <= _totalSupply * maxWalletInPermille / 1000, "MaxWallet");
            if(!isExludedFromMaxWallet[sender]) require(amount <= _totalSupply * maxWalletInPermille * maxTx / 1000 / 100, "MaxTx");
        }
    }

function _lowGasTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
        require(sender != address(0), "Can't use zero addresses here");
        require(amount <= _balances[sender], "Can't transfer more than you own");
        if(amount == 0) return true;
        _balances[sender] -= amount;
        _balances[recipient] += amount;
        emit Transfer(sender, recipient, amount);
        return true;
    }
}

Try to fetch constructor arguments automatically

No

Yes

ABI-encoded Constructor Arguments (if required by the contract)

New Solidity Smart Contract Verification

Contract Libraries