Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function transfer(address to, uint256 ...
•    - function transferFrom(address from, a ...
•    - function nonces(address owner)
•    - function permit(
•    - function DOMAIN_SEPARATOR()
•    - function _mint(address to, uint256 am ...
•    - function _burn(address from, uint256 ...
•    - function _transfer(address from, addr ...
•    - function _spendAllowance(address owne ...
•    - function _approve(address owner, addr ...
•    - function _beforeTokenTransfer(address ...
•    - function _afterTokenTransfer(address ...
•  contract FlyCoin is ERC20 *
•    - function name()
•    - function symbol()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-07-07
*/

// SPDX-License-Identifier: MIT

// File solady/src/tokens/[email protected]


pragma solidity ^0.8.4;

/// @notice Simple ERC20 + EIP-2612 implementation.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)
///
/// @dev Note:
/// The ERC20 standard allows minting and transferring to and from the zero address,
/// minting and transferring zero tokens, as well as self-approvals.
/// For performance, this implementation WILL NOT revert for such actions.
/// Please add any checks with overrides if desired.
abstract contract ERC20 {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The total supply has overflowed.
    error TotalSupplyOverflow();

    /// @dev The allowance has overflowed.
    error AllowanceOverflow();

    /// @dev The allowance has underflowed.
    error AllowanceUnderflow();

    /// @dev Insufficient balance.
    error InsufficientBalance();

    /// @dev Insufficient allowance.
    error InsufficientAllowance();

    /// @dev The permit is invalid.
    error InvalidPermit();

    /// @dev The permit has expired.
    error PermitExpired();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Emitted when `amount` tokens is transferred from `from` to `to`.
    event Transfer(address indexed from, address indexed to, uint256 amount);

    /// @dev Emitted when `amount` tokens is approved by `owner` to be used by `spender`.
    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /// @dev `keccak256(bytes("Transfer(address,address,uint256)"))`.
    uint256 private constant _TRANSFER_EVENT_SIGNATURE =
        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;

    /// @dev `keccak256(bytes("Approval(address,address,uint256)"))`.
    uint256 private constant _APPROVAL_EVENT_SIGNATURE =
        0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The storage slot for the total supply.
    uint256 private constant _TOTAL_SUPPLY_SLOT = 0x05345cdf77eb68f44c;

    /// @dev The balance slot of `owner` is given by:
    /// ```
    ///     mstore(0x0c, _BALANCE_SLOT_SEED)
    ///     mstore(0x00, owner)
    ///     let balanceSlot := keccak256(0x0c, 0x20)
    /// ```
    uint256 private constant _BALANCE_SLOT_SEED = 0x87a211a2;

    /// @dev The allowance slot of (`owner`, `spender`) is given by:
    /// ```
    ///     mstore(0x20, spender)
    ///     mstore(0x0c, _ALLOWANCE_SLOT_SEED)
    ///     mstore(0x00, owner)
    ///     let allowanceSlot := keccak256(0x0c, 0x34)
    /// ```
    uint256 private constant _ALLOWANCE_SLOT_SEED = 0x7f5e9f20;

    /// @dev The nonce slot of `owner` is given by:
    /// ```
    ///     mstore(0x0c, _NONCES_SLOT_SEED)
    ///     mstore(0x00, owner)
    ///     let nonceSlot := keccak256(0x0c, 0x20)
    /// ```
    uint256 private constant _NONCES_SLOT_SEED = 0x38377508;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       ERC20 METADATA                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the name of the token.
    function name() public view virtual returns (string memory);

    /// @dev Returns the symbol of the token.
    function symbol() public view virtual returns (string memory);

    /// @dev Returns the decimals places of the token.
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           ERC20                            */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the amount of tokens in existence.
    function totalSupply() public view virtual returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(_TOTAL_SUPPLY_SLOT)
        }
    }

    /// @dev Returns the amount of tokens owned by `owner`.
    function balanceOf(address owner) public view virtual returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x0c, _BALANCE_SLOT_SEED)
            mstore(0x00, owner)
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`.
    function allowance(address owner, address spender)
        public
        view
        virtual
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, spender)
            mstore(0x0c, _ALLOWANCE_SLOT_SEED)
            mstore(0x00, owner)
            result := sload(keccak256(0x0c, 0x34))
        }
    }

    /// @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
    ///
    /// Emits a {Approval} event.
    function approve(address spender, uint256 amount) public virtual returns (bool) {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the allowance slot and store the amount.
            mstore(0x20, spender)
            mstore(0x0c, _ALLOWANCE_SLOT_SEED)
            mstore(0x00, caller())
            sstore(keccak256(0x0c, 0x34), amount)
            // Emit the {Approval} event.
            mstore(0x00, amount)
            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))
        }
        return true;
    }

    /// @dev Atomically increases the allowance granted to `spender` by the caller.
    ///
    /// Emits a {Approval} event.
    function increaseAllowance(address spender, uint256 difference) public virtual returns (bool) {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the allowance slot and load its value.
            mstore(0x20, spender)
            mstore(0x0c, _ALLOWANCE_SLOT_SEED)
            mstore(0x00, caller())
            let allowanceSlot := keccak256(0x0c, 0x34)
            let allowanceBefore := sload(allowanceSlot)
            // Add to the allowance.
            let allowanceAfter := add(allowanceBefore, difference)
            // Revert upon overflow.
            if lt(allowanceAfter, allowanceBefore) {
                mstore(0x00, 0xf9067066) // `AllowanceOverflow()`.
                revert(0x1c, 0x04)
            }
            // Store the updated allowance.
            sstore(allowanceSlot, allowanceAfter)
            // Emit the {Approval} event.
            mstore(0x00, allowanceAfter)
            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))
        }
        return true;
    }

    /// @dev Atomically decreases the allowance granted to `spender` by the caller.
    ///
    /// Emits a {Approval} event.
    function decreaseAllowance(address spender, uint256 difference) public virtual returns (bool) {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the allowance slot and load its value.
            mstore(0x20, spender)
            mstore(0x0c, _ALLOWANCE_SLOT_SEED)
            mstore(0x00, caller())
            let allowanceSlot := keccak256(0x0c, 0x34)
            let allowanceBefore := sload(allowanceSlot)
            // Revert if will underflow.
            if lt(allowanceBefore, difference) {
                mstore(0x00, 0x8301ab38) // `AllowanceUnderflow()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated allowance.
            let allowanceAfter := sub(allowanceBefore, difference)
            sstore(allowanceSlot, allowanceAfter)
            // Emit the {Approval} event.
            mstore(0x00, allowanceAfter)
            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))
        }
        return true;
    }

    /// @dev Transfer `amount` tokens from the caller to `to`.
    ///
    /// Requirements:
    /// - `from` must at least have `amount`.
    ///
    /// Emits a {Transfer} event.
    function transfer(address to, uint256 amount) public virtual returns (bool) {
        _beforeTokenTransfer(msg.sender, to, amount);
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the balance slot and load its value.
            mstore(0x0c, _BALANCE_SLOT_SEED)
            mstore(0x00, caller())
            let fromBalanceSlot := keccak256(0x0c, 0x20)
            let fromBalance := sload(fromBalanceSlot)
            // Revert if insufficient balance.
            if gt(amount, fromBalance) {
                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance.
            sstore(fromBalanceSlot, sub(fromBalance, amount))
            // Compute the balance slot of `to`.
            mstore(0x00, to)
            let toBalanceSlot := keccak256(0x0c, 0x20)
            // Add and store the updated balance of `to`.
            // Will not overflow because the sum of all user balances
            // cannot exceed the maximum uint256 value.
            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
            // Emit the {Transfer} event.
            mstore(0x20, amount)
            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, caller(), shr(96, mload(0x0c)))
        }
        _afterTokenTransfer(msg.sender, to, amount);
        return true;
    }

    /// @dev Transfers `amount` tokens from `from` to `to`.
    ///
    /// Note: Does not update the allowance if it is the maximum uint256 value.
    ///
    /// Requirements:
    /// - `from` must at least have `amount`.
    /// - The caller must have at least `amount` of allowance to transfer the tokens of `from`.
    ///
    /// Emits a {Transfer} event.
    function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
        _beforeTokenTransfer(from, to, amount);
        /// @solidity memory-safe-assembly
        assembly {
            let from_ := shl(96, from)
            // Compute the allowance slot and load its value.
            mstore(0x20, caller())
            mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))
            let allowanceSlot := keccak256(0x0c, 0x34)
            let allowance_ := sload(allowanceSlot)
            // If the allowance is not the maximum uint256 value.
            if iszero(eq(allowance_, not(0))) {
                // Revert if the amount to be transferred exceeds the allowance.
                if gt(amount, allowance_) {
                    mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.
                    revert(0x1c, 0x04)
                }
                // Subtract and store the updated allowance.
                sstore(allowanceSlot, sub(allowance_, amount))
            }
            // Compute the balance slot and load its value.
            mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))
            let fromBalanceSlot := keccak256(0x0c, 0x20)
            let fromBalance := sload(fromBalanceSlot)
            // Revert if insufficient balance.
            if gt(amount, fromBalance) {
                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance.
            sstore(fromBalanceSlot, sub(fromBalance, amount))
            // Compute the balance slot of `to`.
            mstore(0x00, to)
            let toBalanceSlot := keccak256(0x0c, 0x20)
            // Add and store the updated balance of `to`.
            // Will not overflow because the sum of all user balances
            // cannot exceed the maximum uint256 value.
            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
            // Emit the {Transfer} event.
            mstore(0x20, amount)
            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))
        }
        _afterTokenTransfer(from, to, amount);
        return true;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          EIP-2612                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the current nonce for `owner`.
    /// This value is used to compute the signature for EIP-2612 permit.
    function nonces(address owner) public view virtual returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the nonce slot and load its value.
            mstore(0x0c, _NONCES_SLOT_SEED)
            mstore(0x00, owner)
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /// @dev Sets `value` as the allowance of `spender` over the tokens of `owner`,
    /// authorized by a signed approval by `owner`.
    ///
    /// Emits a {Approval} event.
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        bytes32 domainSeparator = DOMAIN_SEPARATOR();
        /// @solidity memory-safe-assembly
        assembly {
            // Grab the free memory pointer.
            let m := mload(0x40)
            // Revert if the block timestamp greater than `deadline`.
            if gt(timestamp(), deadline) {
                mstore(0x00, 0x1a15a3cc) // `PermitExpired()`.
                revert(0x1c, 0x04)
            }
            // Clean the upper 96 bits.
            owner := shr(96, shl(96, owner))
            spender := shr(96, shl(96, spender))
            // Compute the nonce slot and load its value.
            mstore(0x0c, _NONCES_SLOT_SEED)
            mstore(0x00, owner)
            let nonceSlot := keccak256(0x0c, 0x20)
            let nonceValue := sload(nonceSlot)
            // Increment and store the updated nonce.
            sstore(nonceSlot, add(nonceValue, 1))
            // Prepare the inner hash.
            // `keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)")`.
            // forgefmt: disable-next-item
            mstore(m, 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9)
            mstore(add(m, 0x20), owner)
            mstore(add(m, 0x40), spender)
            mstore(add(m, 0x60), value)
            mstore(add(m, 0x80), nonceValue)
            mstore(add(m, 0xa0), deadline)
            // Prepare the outer hash.
            mstore(0, 0x1901)
            mstore(0x20, domainSeparator)
            mstore(0x40, keccak256(m, 0xc0))
            // Prepare the ecrecover calldata.
            mstore(0, keccak256(0x1e, 0x42))
            mstore(0x20, and(0xff, v))
            mstore(0x40, r)
            mstore(0x60, s)
            pop(staticcall(gas(), 1, 0, 0x80, 0x20, 0x20))
            // If the ecrecover fails, the returndatasize will be 0x00,
            // `owner` will be be checked if it equals the hash at 0x00,
            // which evaluates to false (i.e. 0), and we will revert.
            // If the ecrecover succeeds, the returndatasize will be 0x20,
            // `owner` will be compared against the returned address at 0x20.
            if iszero(eq(mload(returndatasize()), owner)) {
                mstore(0x00, 0xddafbaef) // `InvalidPermit()`.
                revert(0x1c, 0x04)
            }
            // Compute the allowance slot and store the value.
            // The `owner` is already at slot 0x20.
            mstore(0x40, or(shl(160, _ALLOWANCE_SLOT_SEED), spender))
            sstore(keccak256(0x2c, 0x34), value)
            // Emit the {Approval} event.
            log3(add(m, 0x60), 0x20, _APPROVAL_EVENT_SIGNATURE, owner, spender)
            mstore(0x40, m) // Restore the free memory pointer.
            mstore(0x60, 0) // Restore the zero pointer.
        }
    }

    /// @dev Returns the EIP-2612 domains separator.
    function DOMAIN_SEPARATOR() public view virtual returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40) // Grab the free memory pointer.
        }
        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.
        bytes32 nameHash = keccak256(bytes(name()));
        /// @solidity memory-safe-assembly
        assembly {
            let m := result
            // `keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")`.
            // forgefmt: disable-next-item
            mstore(m, 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f)
            mstore(add(m, 0x20), nameHash)
            // `keccak256("1")`.
            // forgefmt: disable-next-item
            mstore(add(m, 0x40), 0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6)
            mstore(add(m, 0x60), chainid())
            mstore(add(m, 0x80), address())
            result := keccak256(m, 0xa0)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  INTERNAL MINT FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Mints `amount` tokens to `to`, increasing the total supply.
    ///
    /// Emits a {Transfer} event.
    function _mint(address to, uint256 amount) internal virtual {
        _beforeTokenTransfer(address(0), to, amount);
        /// @solidity memory-safe-assembly
        assembly {
            let totalSupplyBefore := sload(_TOTAL_SUPPLY_SLOT)
            let totalSupplyAfter := add(totalSupplyBefore, amount)
            // Revert if the total supply overflows.
            if lt(totalSupplyAfter, totalSupplyBefore) {
                mstore(0x00, 0xe5cfe957) // `TotalSupplyOverflow()`.
                revert(0x1c, 0x04)
            }
            // Store the updated total supply.
            sstore(_TOTAL_SUPPLY_SLOT, totalSupplyAfter)
            // Compute the balance slot and load its value.
            mstore(0x0c, _BALANCE_SLOT_SEED)
            mstore(0x00, to)
            let toBalanceSlot := keccak256(0x0c, 0x20)
            // Add and store the updated balance.
            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
            // Emit the {Transfer} event.
            mstore(0x20, amount)
            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, mload(0x0c)))
        }
        _afterTokenTransfer(address(0), to, amount);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  INTERNAL BURN FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Burns `amount` tokens from `from`, reducing the total supply.
    ///
    /// Emits a {Transfer} event.
    function _burn(address from, uint256 amount) internal virtual {
        _beforeTokenTransfer(from, address(0), amount);
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the balance slot and load its value.
            mstore(0x0c, _BALANCE_SLOT_SEED)
            mstore(0x00, from)
            let fromBalanceSlot := keccak256(0x0c, 0x20)
            let fromBalance := sload(fromBalanceSlot)
            // Revert if insufficient balance.
            if gt(amount, fromBalance) {
                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance.
            sstore(fromBalanceSlot, sub(fromBalance, amount))
            // Subtract and store the updated total supply.
            sstore(_TOTAL_SUPPLY_SLOT, sub(sload(_TOTAL_SUPPLY_SLOT), amount))
            // Emit the {Transfer} event.
            mstore(0x00, amount)
            log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), 0)
        }
        _afterTokenTransfer(from, address(0), amount);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                INTERNAL TRANSFER FUNCTIONS                 */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Moves `amount` of tokens from `from` to `to`.
    function _transfer(address from, address to, uint256 amount) internal virtual {
        _beforeTokenTransfer(from, to, amount);
        /// @solidity memory-safe-assembly
        assembly {
            let from_ := shl(96, from)
            // Compute the balance slot and load its value.
            mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))
            let fromBalanceSlot := keccak256(0x0c, 0x20)
            let fromBalance := sload(fromBalanceSlot)
            // Revert if insufficient balance.
            if gt(amount, fromBalance) {
                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance.
            sstore(fromBalanceSlot, sub(fromBalance, amount))
            // Compute the balance slot of `to`.
            mstore(0x00, to)
            let toBalanceSlot := keccak256(0x0c, 0x20)
            // Add and store the updated balance of `to`.
            // Will not overflow because the sum of all user balances
            // cannot exceed the maximum uint256 value.
            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
            // Emit the {Transfer} event.
            mstore(0x20, amount)
            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))
        }
        _afterTokenTransfer(from, to, amount);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                INTERNAL ALLOWANCE FUNCTIONS                */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Updates the allowance of `owner` for `spender` based on spent `amount`.
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the allowance slot and load its value.
            mstore(0x20, spender)
            mstore(0x0c, _ALLOWANCE_SLOT_SEED)
            mstore(0x00, owner)
            let allowanceSlot := keccak256(0x0c, 0x34)
            let allowance_ := sload(allowanceSlot)
            // If the allowance is not the maximum uint256 value.
            if iszero(eq(allowance_, not(0))) {
                // Revert if the amount to be transferred exceeds the allowance.
                if gt(amount, allowance_) {
                    mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.
                    revert(0x1c, 0x04)
                }
                // Subtract and store the updated allowance.
                sstore(allowanceSlot, sub(allowance_, amount))
            }
        }
    }

    /// @dev Sets `amount` as the allowance of `spender` over the tokens of `owner`.
    ///
    /// Emits a {Approval} event.
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            let owner_ := shl(96, owner)
            // Compute the allowance slot and store the amount.
            mstore(0x20, spender)
            mstore(0x0c, or(owner_, _ALLOWANCE_SLOT_SEED))
            sstore(keccak256(0x0c, 0x34), amount)
            // Emit the {Approval} event.
            mstore(0x00, amount)
            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, shr(96, owner_), shr(96, mload(0x2c)))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     HOOKS TO OVERRIDE                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Hook that is called before any transfer of tokens.
    /// This includes minting and burning.
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /// @dev Hook that is called after any transfer of tokens.
    /// This includes minting and burning.
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}





pragma solidity ^0.8.9;

contract FlyCoin is ERC20 {

    function name() public pure virtual override returns (string memory) {
        return "FlyCoin";
    }

    function symbol() public pure virtual override returns (string memory) {
        return "FLY";
    }

    constructor() {
        _mint(msg.sender, 1717171717 ether);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AllowanceOverflow","type":"error"},{"inputs":[],"name":"AllowanceUnderflow","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InvalidPermit","type":"error"},{"inputs":[],"name":"PermitExpired","type":"error"},{"inputs":[],"name":"TotalSupplyOverflow","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"result","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"difference","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"difference","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

26405:328:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26440:104;26520:16;;;;;;;;;;;;-1:-1:-1;;;26520:16:0;;;;26440:104;;;;;;;:::i;:::-;;;;;;;;6192:586;;;;;;:::i;:::-;;:::i;:::-;;;1169:14:1;;1162:22;1144:41;;1132:2;1117:18;6192:586:0;1004:187:1;5008:200:0;5171:18;5165:25;5008:200;;;1342:25:1;;;1330:2;1315:18;5008:200:0;1196:177:1;11199:2247:0;;;;;;:::i;:::-;;:::i;4572:84::-;;;4646:2;1853:36:1;;1841:2;1826:18;4572:84:0;1711:184:1;17544:1083:0;;;:::i;6915:1081::-;;;;;;:::i;:::-;;:::i;5277:293::-;;;;;;:::i;:::-;5448:18;5442:4;5435:32;;;5340:14;5481:19;;;;5546:4;5530:21;;5524:28;;5277:293;13868:348;;;;;;:::i;:::-;14095:17;14089:4;14082:31;;;13928:14;14127:19;;;;14192:4;14176:21;;14170:28;;13868:348;26552:102;26634:12;;;;;;;;;;;;-1:-1:-1;;;26634:12:0;;;;26552:102;;8133:1057;;;;;;:::i;:::-;;:::i;9385:1435::-;;;;;;:::i;:::-;;:::i;14406:3076::-;;;;;;:::i;:::-;;:::i;:::-;;5668:388;;;;;;:::i;:::-;5891:4;5884:21;5932:20;5926:4;5919:34;;;5784:14;5967:19;;;;6032:4;6016:21;;6010:28;;5668:388;6192:586;6266:4;6429:7;6423:4;6416:21;6464:20;6458:4;6451:34;6512:8;6506:4;6499:22;6565:6;6558:4;6552;6542:21;6535:37;6642:6;6636:4;6629:20;6731:4;6725:11;6721:2;6717:20;6707:8;-1:-1:-1;;;;;;;;;;;6674:4:0;6668;6663:75;-1:-1:-1;6766:4:0;6192:586;;;;:::o;11199:2247::-;11287:4;11442;11438:2;11434:13;11537:8;11531:4;11524:22;11583:20;11576:5;11573:31;11567:4;11560:45;11656:4;11650;11640:21;11699:13;11693:20;11823:1;11819:6;11807:10;11804:22;11794:438;;11943:10;11935:6;11932:22;11929:162;;;11991:10;11985:4;11978:24;12067:4;12061;12054:18;11929:162;12209:6;12197:10;12193:23;12178:13;12171:46;11794:438;;;12330:18;12323:5;12320:29;12314:4;12307:43;12403:4;12397;12387:21;12447:15;12441:22;12539:11;12531:6;12528:23;12525:149;;;12584:10;12578:4;12571:24;12654:4;12648;12641:18;12525:149;12785:6;12772:11;12768:24;12751:15;12744:49;;;12870:2;12864:4;12857:16;12924:4;12918;12908:21;13178:6;13162:13;13156:20;13152:33;13137:13;13130:56;;13256:6;13250:4;13243:20;13351:4;13345:11;13341:2;13337:20;13329:5;13325:2;13321:14;13294:25;13288:4;13282;13277:81;;-1:-1:-1;13434:4:0;11199:2247;;;;;:::o;17544:1083::-;17712:4;17706:11;;26520:16;;;;;;;18186:66;18176:77;;17885:24;26520:16;;;18267:30;18410:66;18389:88;;;18512:9;18505:4;18498:12;;18491:31;18557:9;18550:4;18543:12;;18536:31;18604:4;18591:18;;;17544:1083::o;6915:1081::-;7003:4;7164:7;7158:4;7151:21;7199:20;7193:4;7186:34;7247:8;7241:4;7234:22;7307:4;7301;7291:21;7355:13;7349:20;7464:10;7447:15;7443:32;7549:15;7533:14;7530:35;7527:159;;;7598:10;7592:4;7585:24;7666:4;7660;7653:18;7527:159;7767:14;7752:13;7745:37;7852:14;7846:4;7839:28;;;;7949:4;7943:11;7939:2;7935:20;7925:8;-1:-1:-1;;;;;;;;;;;7892:4:0;7886;7881:75;-1:-1:-1;7984:4:0;6915:1081;;;;:::o;8133:1057::-;8221:4;8382:7;8376:4;8369:21;8417:20;8411:4;8404:34;8465:8;8459:4;8452:22;8525:4;8519;8509:21;8573:13;8567:20;8666:10;8649:15;8646:31;8643:156;;;8710:10;8704:4;8697:24;8779:4;8773;8766:18;8643:156;8914:10;8897:15;8893:32;8871:54;;8961:14;8946:13;8939:37;9046:14;9040:4;9033:28;;;9143:4;9137:11;9133:2;9129:20;9119:8;-1:-1:-1;;;;;;;;;;;9086:4:0;9080;9075:75;-1:-1:-1;9178:4:0;8133:1057;;;;:::o;9385:1435::-;9455:4;9669:18;9663:4;9656:32;9715:8;9709:4;9702:22;9777:4;9771;9761:21;9821:15;9815:22;9913:11;9905:6;9902:23;9899:149;;;9958:10;9952:4;9945:24;10028:4;10022;10015:18;9899:149;10159:6;10146:11;10142:24;10125:15;10118:49;;;10244:2;10238:4;10231:16;10298:4;10292;10282:21;10552:6;10536:13;10530:20;10526:33;10511:13;10504:56;;10630:6;10624:4;10617:20;10719:4;10713:11;10709:2;10705:20;10695:8;10668:25;10662:4;10656;10651:75;-1:-1:-1;10808:4:0;9385:1435;;;;:::o;14406:3076::-;14614:23;14640:18;:16;:18::i;:::-;14614:44;;14798:4;14792:11;14907:8;14894:11;14891:25;14888:145;;;14949:10;14943:4;14936:24;15013:4;15007;15000:18;14888:145;15113:5;15109:2;15105:14;15101:2;15097:23;15088:32;;15161:7;15157:2;15153:16;15149:2;15145:25;15134:36;;15256:17;15250:4;15243:31;15301:5;15295:4;15288:19;15354:4;15348;15338:21;15397:9;15391:16;15510:1;15498:10;15494:18;15483:9;15476:37;15736:66;15733:1;15726:77;15838:5;15831:4;15828:1;15824:12;15817:27;15879:7;15872:4;15869:1;15865:12;15858:29;15922:5;15915:4;15912:1;15908:12;15901:27;15963:10;15956:4;15953:1;15949:12;15942:32;;;16009:8;16002:4;15999:1;15995:12;15988:30;16082:6;16079:1;16072:17;16116:15;16110:4;16103:29;16172:4;16169:1;16159:18;16153:4;16146:32;16266:4;16260;16250:21;16247:1;16240:32;16309:1;16303:4;16299:12;16293:4;16286:26;16339:1;16333:4;16326:15;16368:1;16362:4;16355:15;16424:4;16418;16412;16409:1;16406;16399:5;16388:41;16384:46;16855:5;16836:16;16830:23;16827:34;16817:162;;16895:10;16889:4;16882:24;16959:4;16953;16946:18;16817:162;-1:-1:-1;;;17123:43:0;;17117:4;17110:57;17204:4;17198;17188:21;17181:36;;;17158:7;17326:5;-1:-1:-1;;;;;;;;;;;;17286:4:0;17279:12;;17274:67;17362:4;17355:15;-1:-1:-1;;17433:1:0;17427:4;17420:15;-1:-1:-1;;;;;;14406:3076:0:o;14:548:1:-;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;298:3;483:1;478:2;469:6;458:9;454:22;450:31;443:42;553:2;546;542:7;537:2;529:6;525:15;521:29;510:9;506:45;502:54;494:62;;;;14:548;;;;:::o;567:173::-;635:20;;-1:-1:-1;;;;;684:31:1;;674:42;;664:70;;730:1;727;720:12;664:70;567:173;;;:::o;745:254::-;813:6;821;874:2;862:9;853:7;849:23;845:32;842:52;;;890:1;887;880:12;842:52;913:29;932:9;913:29;:::i;:::-;903:39;989:2;974:18;;;;961:32;;-1:-1:-1;;;745:254:1:o;1378:328::-;1455:6;1463;1471;1524:2;1512:9;1503:7;1499:23;1495:32;1492:52;;;1540:1;1537;1530:12;1492:52;1563:29;1582:9;1563:29;:::i;:::-;1553:39;;1611:38;1645:2;1634:9;1630:18;1611:38;:::i;:::-;1601:48;;1696:2;1685:9;1681:18;1668:32;1658:42;;1378:328;;;;;:::o;2082:186::-;2141:6;2194:2;2182:9;2173:7;2169:23;2165:32;2162:52;;;2210:1;2207;2200:12;2162:52;2233:29;2252:9;2233:29;:::i;:::-;2223:39;2082:186;-1:-1:-1;;;2082:186:1:o;2273:693::-;2384:6;2392;2400;2408;2416;2424;2432;2485:3;2473:9;2464:7;2460:23;2456:33;2453:53;;;2502:1;2499;2492:12;2453:53;2525:29;2544:9;2525:29;:::i;:::-;2515:39;;2573:38;2607:2;2596:9;2592:18;2573:38;:::i;:::-;2563:48;;2658:2;2647:9;2643:18;2630:32;2620:42;;2709:2;2698:9;2694:18;2681:32;2671:42;;2763:3;2752:9;2748:19;2735:33;2808:4;2801:5;2797:16;2790:5;2787:27;2777:55;;2828:1;2825;2818:12;2777:55;2273:693;;;;-1:-1:-1;2273:693:1;;;;2851:5;2903:3;2888:19;;2875:33;;-1:-1:-1;2955:3:1;2940:19;;;2927:33;;2273:693;-1:-1:-1;;2273:693:1:o;2971:260::-;3039:6;3047;3100:2;3088:9;3079:7;3075:23;3071:32;3068:52;;;3116:1;3113;3106:12;3068:52;3139:29;3158:9;3139:29;:::i;:::-;3129:39;;3187:38;3221:2;3210:9;3206:18;3187:38;:::i;:::-;3177:48;;2971:260;;;;;:::o

ipfs://b055dfb223b5415e4fb11d227157147022d52b2b1badac5b27b53b0b1e9d82f0