Contract

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import {ERC20} from "./ERC20.sol";

contract Bitconnect20 is ERC20 {

    uint256 private constant _MAX_SUPPLY = 420_690_000_000_000 ether;

    /// @dev Transfer to zero address.
    error TransferZeroAddress();

    /// @dev Transfer zero amount.
    error TransferZeroAmount();

    constructor(address _recipient) {
        _mint(_recipient, _MAX_SUPPLY);
    }

    /// @dev Returns the name of the token.
    function name() public pure override returns (string memory) {
        return "BitConnect 2.0";
    }

    /// @dev Returns the symbol of the token.
    function symbol() public pure override returns (string memory) {
        return "BITCONNECT2.0";
    }

    function _beforeTokenTransfer(address, address to, uint256 amount) internal override virtual {
        if (to == address(0)) revert TransferZeroAddress();
        if (amount == 0) revert TransferZeroAmount();
    }
}

// SPDX-License-Identifier: MIT
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 {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_recipient","type":"address"}],"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"},{"inputs":[],"name":"TransferZeroAddress","type":"error"},{"inputs":[],"name":"TransferZeroAmount","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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

000000000000000000000000b7188e77cd796fa5c7135e349fc7249a5210b001

-----Decoded View---------------
Arg [0] : _recipient (address): 0xB7188e77Cd796fA5C7135e349FC7249A5210B001

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000b7188e77cd796fa5c7135e349fc7249a5210b001

93:856:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;472:101;543:23;;;;;;;;;;;;;;;;;472:101;;;;;;;:::i;:::-;;;;;;;;5995:573:1;;;;;;:::i;:::-;;:::i;:::-;;;1251:14:2;;1244:22;1226:41;;1214:2;1199:18;5995:573:1;1086:187:2;4847:195:1;5007:18;5001:25;4847:195;;;1424:25:2;;;1412:2;1397:18;4847:195:1;1278:177:2;10886:2203:1;;;;;;:::i;:::-;;:::i;4420:82::-;;;4493:2;1935:36:2;;1923:2;1908:18;4420:82:1;1793:184:2;17096:1062:1;17261:4;17255:11;;543:23:0;;;;;;;17726:66:1;17716:77;;17431:24;543:23:0;;;17806:30:1;17946:66;17925:88;;;18047:9;18040:4;18033:12;;18026:31;18091:9;18084:4;18077:12;;18070:31;18137:4;18124:18;;17096:1062;;6700:1058;;;;;;:::i;:::-;;:::i;5108:286::-;;;;;;:::i;:::-;5276:18;5270:4;5263:32;;;5171:14;5308:19;;;;5372:4;5356:21;;5350:28;;5108:286;13503:340;;;;;;:::i;:::-;13726:17;13720:4;13713:31;;;13563:14;13757:19;;;;13821:4;13805:21;;13799:28;;13503:340;625:102:0;698:22;;;;;;;;;;;;;;;;;625:102;;7890:1035:1;;;;;;:::i;:::-;;:::i;9112:1406::-;;;;;;:::i;:::-;;:::i;14027:3010::-;;;;;;:::i;:::-;;:::i;:::-;;5489:375;;;;;;:::i;:::-;5704:4;5697:21;5744:20;5738:4;5731:34;;;5601:14;5778:19;;;;5842:4;5826:21;;5820:28;;5489:375;5995:573;6069:4;6228:7;6222:4;6215:21;6262:20;6256:4;6249:34;6309:8;6303:4;6296:22;6361:6;6354:4;6348;6338:21;6331:37;6436:6;6430:4;6423:20;6524:4;6518:11;6514:2;6510:20;6500:8;6473:25;6467:4;6461;6456:75;-1:-1:-1;6557:4:1;5995:573;;;;:::o;10886:2203::-;10974:4;10990:38;11011:4;11017:2;11021:6;10990:20;:38::i;:::-;11125:4;11121:2;11117:13;11218:8;11212:4;11205:22;11263:20;11256:5;11253:31;11247:4;11240:45;11335:4;11329;11319:21;11377:13;11371:20;11499:1;11495:6;11483:10;11480:22;11470:430;;11617:10;11609:6;11606:22;11603:159;;;11664:10;11658:4;11651:24;11739:4;11733;11726:18;11603:159;11878:6;11866:10;11862:23;11847:13;11840:46;11470:430;;;11996:18;11989:5;11986:29;11980:4;11973:43;12068:4;12062;12052:21;12111:15;12105:22;12201:11;12193:6;12190:23;12187:146;;;12245:10;12239:4;12232:24;12314:4;12308;12301:18;12187:146;12442:6;12429:11;12425:24;12408:15;12401:49;;;12525:2;12519:4;12512:16;12578:4;12572;12562:21;12828:6;12812:13;12806:20;12802:33;12787:13;12780:56;;12904:6;12898:4;12891:20;12998:4;12992:11;12988:2;12984:20;12976:5;12972:2;12968:14;12941:25;12935:4;12929;12924:81;;-1:-1:-1;13078:4:1;10886:2203;;;;;:::o;6700:1058::-;6788:4;6945:7;6939:4;6932:21;6979:20;6973:4;6966:34;7026:8;7020:4;7013:22;7085:4;7079;7069:21;7132:13;7126:20;7239:10;7222:15;7218:32;7322:15;7306:14;7303:35;7300:156;;;7370:10;7364:4;7357:24;7437:4;7431;7424:18;7300:156;7535:14;7520:13;7513:37;7618:14;7612:4;7605:28;;;;7714:4;7708:11;7704:2;7700:20;7690:8;7663:25;7657:4;7651;7646:75;-1:-1:-1;7747:4:1;6700:1058;;;;:::o;7890:1035::-;7978:4;8135:7;8129:4;8122:21;8169:20;8163:4;8156:34;8216:8;8210:4;8203:22;8275:4;8269;8259:21;8322:13;8316:20;8413:10;8396:15;8393:31;8390:153;;;8456:10;8450:4;8443:24;8524:4;8518;8511:18;8390:153;8656:10;8639:15;8635:32;8613:54;;8702:14;8687:13;8680:37;8785:14;8779:4;8772:28;;;8881:4;8875:11;8871:2;8867:20;8857:8;8830:25;8824:4;8818;8813:75;-1:-1:-1;8914:4:1;7890:1035;;;;:::o;9112:1406::-;9182:4;9198:44;9219:10;9231:2;9235:6;9198:20;:44::i;:::-;9391:18;9385:4;9378:32;9436:8;9430:4;9423:22;9497:4;9491;9481:21;9540:15;9534:22;9630:11;9622:6;9619:23;9616:146;;;9674:10;9668:4;9661:24;9743:4;9737;9730:18;9616:146;9871:6;9858:11;9854:24;9837:15;9830:49;;;9954:2;9948:4;9941:16;10007:4;10001;9991:21;10257:6;10241:13;10235:20;10231:33;10216:13;10209:56;;10333:6;10327:4;10320:20;10421:4;10415:11;10411:2;10407:20;10397:8;10370:25;10364:4;10358;10353:75;-1:-1:-1;10507:4:1;9112:1406;;;;:::o;14027:3010::-;14226:23;14252:18;17261:4;17255:11;;543:23:0;;;;;;;17726:66:1;17716:77;;17431:24;543:23:0;;;17806:30:1;17946:66;17925:88;;;18047:9;18040:4;18033:12;;18026:31;18091:9;18084:4;18077:12;;18070:31;18137:4;18124:18;;;17096:1062;14252:18;14226:44;;14406:4;14400:11;14513:8;14500:11;14497:25;14494:142;;;14554:10;14548:4;14541:24;14617:4;14611;14604:18;14494:142;14714:5;14710:2;14706:14;14702:2;14698:23;14689:32;;14761:7;14757:2;14753:16;14749:2;14745:25;14734:36;;14854:17;14848:4;14841:31;14898:5;14892:4;14885:19;14950:4;14944;14934:21;14992:9;14986:16;15103:1;15091:10;15087:18;15076:9;15069:37;15325:66;15322:1;15315:77;15426:5;15419:4;15416:1;15412:12;15405:27;15466:7;15459:4;15456:1;15452:12;15445:29;15508:5;15501:4;15498:1;15494:12;15487:27;15548:10;15541:4;15538:1;15534:12;15527:32;;;15593:8;15586:4;15583:1;15579:12;15572:30;15664:6;15661:1;15654:17;15697:15;15691:4;15684:29;15752:4;15749:1;15739:18;15733:4;15726:32;15844:4;15838;15828:21;15825:1;15818:32;15886:1;15880:4;15876:12;15870:4;15863:26;15915:1;15909:4;15902:15;15943:1;15937:4;15930:15;15998:4;15992;15986;15983:1;15980;15973:5;15962:41;15958:46;16423:5;16404:16;16398:23;16395:34;16385:159;;16462:10;16456:4;16449:24;16525:4;16519;16512:18;16385:159;16688:30;16685:43;;16679:4;16672:57;16765:4;16759;16749:21;16742:36;;;16720:7;16885:5;16858:25;-1:-1:-1;16845:4:1;16838:12;;16833:67;16920:4;16913:15;-1:-1:-1;;16990:1:1;16984:4;16977:15;-1:-1:-1;;;;;;14027:3010:1:o;733:214:0:-;840:16;;;836:50;;865:21;;;;;;;;;;;;;;836:50;900:6;910:1;900:11;896:44;;920:20;;;;;;;;;;;;;;896:44;733:214;;;:::o;14:607:2:-;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;612:2;542:66;537:2;529:6;525:15;521:88;510:9;506:104;502:113;494:121;;;;14:607;;;;:::o;626:196::-;694:20;;754:42;743:54;;733:65;;723:93;;812:1;809;802:12;723:93;626:196;;;:::o;827:254::-;895:6;903;956:2;944:9;935:7;931:23;927:32;924:52;;;972:1;969;962:12;924:52;995:29;1014:9;995:29;:::i;:::-;985:39;1071:2;1056:18;;;;1043:32;;-1:-1:-1;;;827:254:2:o;1460:328::-;1537:6;1545;1553;1606:2;1594:9;1585:7;1581:23;1577:32;1574:52;;;1622:1;1619;1612:12;1574:52;1645:29;1664:9;1645:29;:::i;:::-;1635:39;;1693:38;1727:2;1716:9;1712:18;1693:38;:::i;:::-;1683:48;;1778:2;1767:9;1763:18;1750:32;1740:42;;1460:328;;;;;:::o;2164:186::-;2223:6;2276:2;2264:9;2255:7;2251:23;2247:32;2244:52;;;2292:1;2289;2282:12;2244:52;2315:29;2334:9;2315:29;:::i;:::-;2305:39;2164:186;-1:-1:-1;;;2164:186:2:o;2355:693::-;2466:6;2474;2482;2490;2498;2506;2514;2567:3;2555:9;2546:7;2542:23;2538:33;2535:53;;;2584:1;2581;2574:12;2535:53;2607:29;2626:9;2607:29;:::i;:::-;2597:39;;2655:38;2689:2;2678:9;2674:18;2655:38;:::i;:::-;2645:48;;2740:2;2729:9;2725:18;2712:32;2702:42;;2791:2;2780:9;2776:18;2763:32;2753:42;;2845:3;2834:9;2830:19;2817:33;2890:4;2883:5;2879:16;2872:5;2869:27;2859:55;;2910:1;2907;2900:12;2859:55;2355:693;;;;-1:-1:-1;2355:693:2;;;;2933:5;2985:3;2970:19;;2957:33;;-1:-1:-1;3037:3:2;3022:19;;;3009:33;;2355:693;-1:-1:-1;;2355:693:2:o;3053:260::-;3121:6;3129;3182:2;3170:9;3161:7;3157:23;3153:32;3150:52;;;3198:1;3195;3188:12;3150:52;3221:29;3240:9;3221:29;:::i;:::-;3211:39;;3269:38;3303:2;3292:9;3288:18;3269:38;:::i;:::-;3259:48;;3053:260;;;;;:::o

ipfs://32b549f8eccb4e0811fb6b77e07053bb108f6608d247396d84b57b94eb08146b