/

    Contract Diff Checker

    Contract Name:
    Token

    Contract Source Code:

    /*
    
     █▀ █▀█ █▄░█ █ █▀▀ █▀▀ ▄▀█ █▀▀ ▀█▀ █▀█ █▀█ █▄█
     ▄█ █▄█ █░▀█ █ █▄▄ █▀░ █▀█ █▄▄ ░█░ █▄█ █▀▄ ░█░
    
      Trade on SonicFactory and have fun!
      Web:      https://sonicfactory.fun/
    
    */
    
    // SPDX-License-Identifier: MIT
    
    pragma solidity ^0.8.24;
    
    import "./ERC20.sol";
    
    contract Token is ERC20 {
      address private immutable _creator;
      address private _owner;
      address private _router;
      address private _pair;
    
      bool private _escaped;
      bool private _initialized;
      uint24 private _maxBalance;
      uint24 private _tax;
      uint32 private _launch;
    
      mapping(address => bool) private _unauthorized;
    
      struct HolderView {
        address holder;
        uint256 balance;
      }
    
      event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    
      error ErrorUnauthorized(address sender);
      error ErrorAlreadyInitialized();
      error ErrorUnapprovable();
      error ErrorMaxBalanceExceeded();
      error ErrorInvalidRecipient(address to);
      error ErrorInvalidRange();
    
      modifier onlyOwner() {
        if (msg.sender != _owner) { revert ErrorUnauthorized(msg.sender); }
    
        _;
      }
    
      constructor(address _owner_, address _creator_, string memory _name_, string memory _symbol_, uint8 _decimals_, uint256 _totalSupply_) ERC20(_name_, _symbol_, _decimals_) payable {
        _creator = _creator_;
        _owner = _owner_;
        _mint(_owner_, _totalSupply_);
      }
    
      function initialize(address _router_, address _pair_, uint24 _maxBalance_, uint24 _tax_, uint32 _launch_, address[] calldata _unauthorized_) external onlyOwner {
        if (_initialized) { revert ErrorAlreadyInitialized(); }
    
        unchecked {
          uint256 cnt = _unauthorized_.length;
    
          for (uint256 i; i < cnt; i++) { _unauthorized[_unauthorized_[i]] = true; }
        }
    
        _router = _router_;
        _pair = _pair_;
        _maxBalance = _maxBalance_;
        _tax = _tax_;
        _launch = _launch_;
        _initialized = true;
      }
    
      function owner() external view returns (address) {
        return _owner;
      }
    
      /// @notice Returns the creator address
      function creator() external view returns (address) {
        return _creator;
      }
    
      function approve(address spender, uint256 value) public override returns (bool) {
        if (!_escaped && spender != _router) { revert ErrorUnapprovable(); }
    
        return super.approve(spender, value);
      }
    
      function permit(address owner_, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public override {
        if (!_escaped && spender != _router) { revert ErrorUnapprovable(); }
    
        super.permit(owner_, spender, value, deadline, v, r, s);
      }
    
      function _transferCheck(address from, address to, uint256 value) private view {
        if (_escaped || ((from == _owner && to == _pair) || ((!_escaped && to == _owner) || value == 0 || to == address(0xdEaD) || to == _router || to == _pair))) { return; }
    
        if (!_escaped) {
          if (_unauthorized[to]) { revert ErrorInvalidRecipient(to); }
    
          unchecked {
            if (_maxBalance == 100_000 || _balance[to] + value <= _percentage(_totalSupply, uint256(_maxBalance))) { return; }
          }
        }
    
        revert ErrorMaxBalanceExceeded();
      }
    
      function transfer(address to, uint256 value) external virtual override returns (bool) {
        _transfer(msg.sender, to, value);
    
        return true;
      }
    
      function _transfer(address from, address to, uint256 value) internal virtual override {
        _transferCheck(from, to, value);
    
        super._transfer(from, to, value);
      }
    
      function transferFrom(address from, address to, uint256 value) public override returns (bool) {
        if (!_escaped && msg.sender == _router && to == _pair && _allowance[from][_router] != type(uint256).max) { super._approve(from, _router, type(uint256).max, false); }
    
        _transferCheck(from, to, value);
    
        return super.transferFrom(from, to, value);
      }
    
      function totalHolders() external view returns (uint24 total) {
        return _totalHolders;
      }
    
      function holders(uint256 offset, uint256 limit) public view returns (HolderView[] memory) {
        if (offset >= _totalHolders) { revert ErrorInvalidRange(); }
    
        unchecked {
          if (offset + limit > _totalHolders) { limit = _totalHolders - offset; }
        }
    
        HolderView[] memory list = new HolderView[](limit);
    
        unchecked {
          uint256 j;
    
          for (uint256 i = offset; j < limit; i++) {
            address holder = _holders[i];
    
            if (holder == address(0xdEaD) || _balance[holder] == 0) { continue; }
    
            list[j].holder = holder;
            list[j].balance = _balance[holder];
    
            ++j;
          }
        }
    
        return list;
      }
    
      function maxBalance() external view returns (uint24) {
        return _maxBalance;
      }
    
      function tax() external view returns (uint24) {
        return _tax;
      }
    
      function launch() external view returns (uint32) {
        return _launch;
      }
    
      /// @notice Returns True if token has reached the target MC and is now tradeable on a public DEX
      function escaped() external view returns (bool) {
        return _escaped;
      }
    
      function escape() external onlyOwner {
        if (_escaped) { revert ErrorUnauthorized(msg.sender); }
        if (_maxBalance < 100_000) { _maxBalance = 100_000; } // 100%
    
        address _previousOwner = _owner;
    
        delete _tax;
        delete _owner;
        delete _router;
        delete _pair;
    
        _escaped = true;
    
        emit OwnershipTransferred(_previousOwner, _owner);
      }
    
      function _percentage(uint256 value, uint256 bps) private pure returns (uint256) {
        unchecked {
          return (value * bps) / 100_000;
        }
      }
    
      function _timestamp() private view returns (uint32) {
        unchecked {
          return uint32(block.timestamp % 2**32);
        }
      }
    }

    // SPDX-License-Identifier: MIT
    
    pragma solidity ^0.8.24;
    
    abstract contract ERC20 {
      uint8 private immutable _decimals;
      uint24 internal _totalHolders;
      uint256 internal _totalSupply;
    
      string private _name;
      string private _symbol;
      bytes32 public immutable DOMAIN_SEPARATOR;
      bytes32 private constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9; // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    
      address[] internal _holders;
    
      mapping(address => uint256) private _nonces;
      mapping(address => uint256) internal _balance;
      mapping(address => mapping(address => uint256)) internal _allowance;
      mapping(address => bool) internal _holderData;
    
      event Approval(address indexed owner, address indexed spender, uint256 value);
      event Transfer(address indexed from, address indexed to, uint256 value);
    
      error ERC20InvalidApprover(address owner);
      error ERC20InvalidSpender(address spender);
      error ERC20InvalidSender(address sender);
      error ERC20InvalidReceiver(address to);
      error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 value);
      error ERC20InsufficientBalance(address owner, uint256 balance, uint256 value);
      error ERC2612ExpiredSignature(uint256 deadline);
      error ERC2612InvalidSigner(address signer, address owner);
    
      constructor(string memory _name_, string memory _symbol_, uint8 _decimals_) {
        _name = _name_;
        _symbol = _symbol_;
        _decimals = _decimals_;
    
        DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), keccak256(bytes(_name)), keccak256(bytes("1")), block.chainid, address(this)));
      }
    
      function name() external view returns (string memory) {
        return _name;
      }
    
      function symbol() external view returns (string memory) {
        return _symbol;
      }
    
      function decimals() external view returns (uint8) {
        return _decimals;
      }
    
      function totalSupply() external view returns (uint256) {
        return _totalSupply;
      }
    
      function balanceOf(address account) external view returns (uint256) {
        return _balance[account];
      }
    
      function allowance(address owner, address spender) public view returns (uint256) {
        return _allowance[owner][spender];
      }
    
      function approve(address spender, uint256 value) public virtual returns (bool) {
        _approve(msg.sender, spender, value, true);
    
        return true;
      }
    
      function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public virtual {
        if (block.timestamp > deadline) { revert ERC2612ExpiredSignature(deadline); }
    
        unchecked {
          address signer = ecrecover(keccak256(abi.encodePacked(hex"1901", DOMAIN_SEPARATOR, keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, _nonces[owner]++, deadline)))), v, r, s);
    
          if (signer != owner) { revert ERC2612InvalidSigner(signer, owner); }
        }
    
        _approve(owner, spender, value, true);
      }
    
      function nonces(address owner) external view returns (uint256) {
        return _nonces[owner];
      }
    
      function transfer(address to, uint256 value) external virtual returns (bool) {
        _transfer(msg.sender, to, value);
    
        return true;
      }
    
      function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        if (value > 0) {
          address spender = msg.sender;
          uint256 allowed = allowance(from, spender);
    
          if (allowed < value) { revert ERC20InsufficientAllowance(to, allowed, value); }
    
          if (allowed != type(uint256).max) {
            unchecked {
              _approve(from, spender, allowed - value, false);
            }
          }
        }
    
        _transfer(from, to, value);
    
        return true;
      }
    
      function burn(uint256 value) external returns (bool) {
        _transfer(msg.sender, address(0xdEaD), value);
    
        return true;
      }
    
      function _approve(address owner, address spender, uint256 value, bool emitEvent) internal {
        if (owner == address(0)) { revert ERC20InvalidApprover(owner); }
        if (spender == address(0)) { revert ERC20InvalidSpender(spender); }
    
        _allowance[owner][spender] = value;
    
        if (emitEvent) { emit Approval(owner, spender, value); }
      }
    
      function _transfer(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) { revert ERC20InvalidSender(from); }
        if (to == address(0) || to == address(this)) { revert ERC20InvalidReceiver(to); }
        if (_balance[from] < value) { revert ERC20InsufficientBalance(from, _balance[from], value); }
    
        if (value > 0) {
          unchecked {
            _balance[from] -= value;
    
            if (_balance[from] == 0) { --_totalHolders; }
    
            if (to == address(0xdEaD)) {
              _totalSupply -= value;
            } else {
              if (_balance[to] == 0) { ++_totalHolders; }
    
              _balance[to] += value;
    
              if (!_holderData[to]) {
                _holderData[to] = true;
                _holders.push(to);
              }
            }
          }
        }
    
        emit Transfer(from, to, value);
      }
    
      function _mint(address to, uint256 value) internal {
        if (to == address(0) || to == address(0xdEaD)) { revert ERC20InvalidReceiver(to); }
    
        unchecked {
          if (_balance[to] == 0) { ++_totalHolders; }
    
          _totalSupply += value;
          _balance[to] += value;
    
          if (!_holderData[to]) {
            _holderData[to] = true;
            _holders.push(to);
          }
        }
    
        emit Transfer(address(0), to, value);
      }
    }

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

    Context size (optional):