Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "./libraries/TransferHelper.sol";
import "./interfaces/INonfungiblePositionManager.sol";
import "./interfaces/IWETH.sol";
import "./interfaces/IUniswapV3Factory.sol";
import "./interfaces/IUniswapV3Pool.sol";
import "./interfaces/IFactory.sol";
import "./libraries/FeeMRegister.sol";
/// @title MintMemeToken Contract
/// @notice This contract implements a fair token distribution mechanism with Uniswap V3 liquidity provision
/// @dev Inherits from OpenZeppelin's ERC20 contract
contract MintMemeToken is ERC20, FeeMRegister {
    using Address for address payable;

    // Constants
    string public constant VERSION = "V2.0.0";
    int24 private constant TICK_LOWER = -887200;
    int24 private constant TICK_UPPER = 887200;
    int24 private constant POOL_FEE = 200;
    uint256 private constant BASE_DENOMINATOR = 100;
    uint256 private constant TOKEN_PRECISION = 1e18;
    uint256 private constant DEFAULT_CALL_GAS_LIMIT = 8000;

    // Immutable state variables
    uint256 public immutable maxMintAmount;
    uint256 public immutable mintAmountPerAddress;
    uint256 public immutable mintStartTime;
    uint256 public immutable etherPerMint;
    uint256 public immutable liquidityAmount;
    address public immutable lpLocker;
    IFactory public immutable factory;
    INonfungiblePositionManager public immutable nonfungiblePositionManager;

    // Mutable state variables
    bool public transfersLocked = true;
    address public poolAddress;

    // Events
    event TransfersUnlocked();
    event LiquidityAddedV3(
        address poolAddress,
        uint256 tokenAmount,
        uint256 ethAmount,
        uint128 liquidity,
        uint256 tokenId
    );
    event CreatorFeePaid(address indexed creator, uint256 amount);
    event CreatorFeeTransferFailed(address indexed creator, uint256 amount);
    event Refunded(
        address indexed user,
        uint256 tokenAmount,
        uint256 etherAmount
    );

    /// @notice Constructs the MintMemeToken contract
    /// @param name The name of the token
    /// @param symbol The symbol of the token
    /// @param totalSupply The total supply of the token
    /// @param totalMinter The total number of minters
    /// @param totalEther The total amount of Ether for minting
    /// @param liquidityPercent The percentage of tokens to be used for liquidity
    /// @param startTime The start time for minting
    /// @param factoryAddress The address of the factory contract
    constructor(
        string memory name,
        string memory symbol,
        uint256 totalSupply,
        uint256 totalMinter,
        uint256 totalEther,
        uint256 liquidityPercent,
        uint256 startTime,
        address factoryAddress
    ) ERC20(name, symbol) {
        factory = IFactory(factoryAddress);
        lpLocker = factory.lpLocker();
        nonfungiblePositionManager = INonfungiblePositionManager(
            factory.nonfungiblePositionManager()
        );

        _validateConstructorParams(
            totalSupply,
            totalMinter,
            liquidityPercent,
            totalEther,
            startTime
        );

        (
            maxMintAmount,
            mintAmountPerAddress,
            liquidityAmount
        ) = _calculateTokenAmounts(totalSupply, totalMinter, liquidityPercent);

        etherPerMint = _calculateEtherPerMint(totalEther, totalMinter);
        mintStartTime = _setMintStartTime(startTime);

        if (totalEther == 0) {
            _unlockTransfers();
        }

        registerMe();
    }

    /// @notice Allows the contract to receive Ether
    receive() external payable {}

    /// @notice Handles the receipt of an ERC721 token
    /// @dev Implements IERC721Receiver
    function onERC721Received(
        address,
        address,
        uint256,
        bytes memory
    ) public virtual returns (bytes4) {
        require(
            msg.sender == address(nonfungiblePositionManager),
            "Not from position manager"
        );
        return this.onERC721Received.selector;
    }

    /// @notice Overrides the ERC20 transfer function to implement transfer locking
    /// @param recipient The address to transfer tokens to
    /// @param amount The amount of tokens to transfer
    function transfer(
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        require(!transfersLocked, "Transfers are locked");
        return super.transfer(recipient, amount);
    }

    /// @notice Overrides the ERC20 transferFrom function to implement transfer locking
    /// @param sender The address to transfer tokens from
    /// @param recipient The address to transfer tokens to
    /// @param amount The amount of tokens to transfer
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        require(!transfersLocked, "Transfers are locked");
        return super.transferFrom(sender, recipient, amount);
    }

    /// @notice Allows users to mint tokens
    function mint() public payable {
        _validateMint();
        _processMint();
    }

    /// @notice Allows users to refund their tokens before transfers are unlocked
    function refund() public {
        require(transfersLocked, "Transfers are not locked");
        require(
            balanceOf(msg.sender) >= mintAmountPerAddress,
            "Insufficient token balance"
        );
        _refund();
    }

    /// @notice Allows users to add liquidity
    function addLiquidity() public {
        _checkAndAddLiquidity();
        _processAddLiquidity();
    }

    /// @notice Validates the constructor parameters
    function _validateConstructorParams(
        uint256 totalSupply,
        uint256 totalMinter,
        uint256 liquidityPercent,
        uint256 totalEther,
        uint256 startTime
    ) private view {
        require(totalSupply > 0, "totalSupply must be greater than 0");
        require(totalMinter > 0, "totalMinter must be greater than 0");

        if (totalEther > 0) {
            require(
                totalEther >= factory.minTotalEther(),
                "totalEther must be greater than minTotalEther"
            );
            require(
                liquidityPercent > 0 && liquidityPercent < BASE_DENOMINATOR,
                "liquidityPercent must be greater than 0 and less than BASE_DENOMINATOR"
            );
        } else {
            require(
                liquidityPercent == 0,
                "liquidityPercent must be 0 when totalEther is 0"
            );
        }

        if (startTime != 0) {
            require(
                startTime > block.timestamp,
                "startTime must be in the future"
            );
        }
        require(
            totalEther % totalMinter == 0,
            "totalEther must evenly divide totalMinter"
        );
    }

    /// @notice Calculates token amounts
    function _calculateTokenAmounts(
        uint256 totalSupply,
        uint256 totalMinter,
        uint256 liquidityPercent
    ) private pure returns (uint256, uint256, uint256) {
        uint256 maxSupply = totalSupply * TOKEN_PRECISION;
        uint256 _liquidityAmount = (maxSupply * liquidityPercent) /
            BASE_DENOMINATOR;
        uint256 _maxMintAmount = maxSupply - _liquidityAmount;
        require(
            _maxMintAmount % totalMinter == 0,
            "maxMintAmount must evenly divide totalMinter"
        );
        uint256 _mintAmountPerAddress = _maxMintAmount / totalMinter;
        return (_maxMintAmount, _mintAmountPerAddress, _liquidityAmount);
    }

    /// @notice Calculates Ether per mint
    function _calculateEtherPerMint(
        uint256 totalEther,
        uint256 totalMinter
    ) private pure returns (uint256) {
        return totalEther / totalMinter;
    }

    /// @notice Sets the mint start time
    function _setMintStartTime(
        uint256 startTime
    ) private view returns (uint256) {
        return startTime == 0 ? block.timestamp : startTime;
    }

    /// @notice Unlocks token transfers
    function _unlockTransfers() private {
        transfersLocked = false;
        emit TransfersUnlocked();
    }

    /// @notice Validates the mint operation
    function _validateMint() private view {
        require(
            block.timestamp >= mintStartTime,
            "minting has not started yet"
        );
        require(
            totalSupply() + mintAmountPerAddress <= maxMintAmount,
            "minting would exceed max supply"
        );
        require(msg.value == etherPerMint, "invalid mint value");
    }

    /// @notice Processes the mint operation
    function _processMint() private {
        _mint(msg.sender, mintAmountPerAddress);
    }

    /// @notice Checks if all tokens are minted and adds liquidity if necessary
    function _checkAndAddLiquidity() private view {
        require(poolAddress == address(0), "liquidity already added");
        require(totalSupply() == maxMintAmount, "minting is not complete");
        require(liquidityAmount > 0, "liquidityAmount is 0");
        require(address(this).balance > 0, "no ether to add liquidity");
    }

    /// @notice Processes the liquidity addition workflow
    /// @dev Unlocks transfers, adds liquidity, and transfers LP token to locker
    function _processAddLiquidity() private {
        _unlockTransfers();
        uint256 tokenId = _addLiquidityToUniswapV3();
        factory.setLPToken(tokenId);
        nonfungiblePositionManager.safeTransferFrom(
            address(this),
            lpLocker,
            tokenId
        );
    }

    /// @notice Adds liquidity to Uniswap V3
    function _addLiquidityToUniswapV3() private returns (uint256) {
        address weth = factory.weth();

        (
            uint256 creatorFee,
            uint256 liquidityEthAmount
        ) = _calculateCreatorFee();

        _setTokenAllowance(weth, liquidityEthAmount);

        IUniswapV3Pool pool = _createPool(
            address(this),
            weth,
            liquidityAmount,
            liquidityEthAmount
        );

        (
            uint256 tokenId,
            uint128 liquidity,
            uint256 amount0,
            uint256 amount1
        ) = _mintLiquidity(
                pool,
                address(this),
                weth,
                liquidityAmount,
                liquidityEthAmount
            );

        _processCreatorFee(creatorFee);

        emit LiquidityAddedV3(
            poolAddress,
            amount0,
            amount1,
            liquidity,
            tokenId
        );
        return tokenId;
    }

    /// @notice Calculates the creator fee and remaining ETH for liquidity
    /// @dev Splits the contract's ETH balance according to the creator fee percentage
    /// @return creatorFee The amount of ETH to be sent to the creator
    /// @return liquidityEthAmount The remaining ETH amount for liquidity provision
    function _calculateCreatorFee()
        private
        view
        returns (uint256 creatorFee, uint256 liquidityEthAmount)
    {
        creatorFee =
            (address(this).balance * factory.creatorFeePercent()) /
            BASE_DENOMINATOR;
        liquidityEthAmount = address(this).balance - creatorFee;
    }

    /// @notice Processes the creator fee payment
    /// @dev Attempts to send fee to creator, falls back to fee address if failed
    /// @param creatorFee The amount of ETH to be sent as creator fee
    function _processCreatorFee(uint256 creatorFee) private {
        address creator = factory.tokenCreators(address(this));
        (bool success, ) = payable(creator).call{
            value: creatorFee,
            gas: DEFAULT_CALL_GAS_LIMIT
        }("");
        if (success) {
            emit CreatorFeePaid(creator, creatorFee);
            return;
        }

        address feeAddress = factory.feeAddress();
        (success, ) = payable(feeAddress).call{
            value: creatorFee,
            gas: DEFAULT_CALL_GAS_LIMIT
        }("");
        if (success) {
            emit CreatorFeePaid(feeAddress, creatorFee);
            return;
        }

        emit CreatorFeeTransferFailed(creator, creatorFee);
    }

    /// @notice Sets token allowances for liquidity provision
    function _setTokenAllowance(
        address weth,
        uint256 liquidityEthAmount
    ) private {
        _mint(address(this), liquidityAmount);
        _approve(
            address(this),
            address(nonfungiblePositionManager),
            liquidityAmount
        );

        IWETH(weth).deposit{value: liquidityEthAmount}();
        TransferHelper.safeApprove(
            weth,
            address(nonfungiblePositionManager),
            liquidityEthAmount
        );
    }

    /// @notice Creates a Uniswap V3 pool
    function _createPool(
        address token0,
        address token1,
        uint256 token0Amount,
        uint256 token1Amount
    ) private returns (IUniswapV3Pool) {
        poolAddress = IUniswapV3Factory(factory.uniswapV3Factory()).createPool(
            token0,
            token1,
            POOL_FEE,
            0
        );
        IUniswapV3Pool pool = IUniswapV3Pool(poolAddress);
        uint256 amount0 = token0 == pool.token0() ? token0Amount : token1Amount;
        uint256 amount1 = token1 == pool.token1() ? token1Amount : token0Amount;
        uint160 sqrtPriceX96 = uint160(
            (_sqrt((amount1 * 1e18) / amount0) * (2 ** 96)) / 1e9
        );
        pool.initialize(sqrtPriceX96);
        return pool;
    }

    /// @notice Mints liquidity in Uniswap V3
    function _mintLiquidity(
        IUniswapV3Pool pool,
        address token0,
        address token1,
        uint256 token0Amount,
        uint256 token1Amount
    ) private returns (uint256, uint128, uint256, uint256) {
        INonfungiblePositionManager.MintParams
            memory params = INonfungiblePositionManager.MintParams({
                token0: pool.token0(),
                token1: pool.token1(),
                tickSpacing: POOL_FEE,
                tickLower: TICK_LOWER,
                tickUpper: TICK_UPPER,
                amount0Desired: token0 == pool.token0()
                    ? token0Amount
                    : token1Amount,
                amount1Desired: token1 == pool.token1()
                    ? token1Amount
                    : token0Amount,
                amount0Min: 0,
                amount1Min: 0,
                recipient: address(this),
                deadline: block.timestamp
            });
        return nonfungiblePositionManager.mint(params);
    }

    /// @notice Calculates the square root of a number
    function _sqrt(uint256 y) private pure returns (uint256 z) {
        if (y > 3) {
            z = y;
            uint256 x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }

    /// @notice Allows users to get a refund while transfers are locked
    /// @dev Burns user's tokens and returns their ETH
    function _refund() internal {
        _burn(msg.sender, mintAmountPerAddress);

        (bool success, ) = payable(msg.sender).call{
            value: etherPerMint,
            gas: DEFAULT_CALL_GAS_LIMIT
        }("");
        require(success, "ETH transfer failed");

        emit Refunded(msg.sender, mintAmountPerAddress, etherPerMint);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC-20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC-721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC-1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC-20
 * applications.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Skips emitting an {Approval} event indicating an allowance update. This is not
     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     *
     * ```solidity
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance < type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Interface for the optional metadata functions from the ERC-20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
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.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.20;

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

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC-721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC-721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
     *   {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.2.0) (utils/Address.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert Errors.InsufficientBalance(address(this).balance, amount);
        }

        (bool success, bytes memory returndata) = recipient.call{value: amount}("");
        if (!success) {
            _revert(returndata);
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {Errors.FailedCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert Errors.InsufficientBalance(address(this).balance, value);
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case
     * of an unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {Errors.FailedCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            assembly ("memory-safe") {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert Errors.FailedCall();
        }
    }
}

// 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;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of common custom errors used in multiple contracts
 *
 * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
 * It is recommended to avoid relying on the error API for critical functionality.
 *
 * _Available since v5.1._
 */
library Errors {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error InsufficientBalance(uint256 balance, uint256 needed);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedCall();

    /**
     * @dev The deployment failed.
     */
    error FailedDeployment();

    /**
     * @dev A necessary precompile is missing.
     */
    error MissingPrecompile(address);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

interface IFactory {
    function uniswapV3Factory() external view returns (address);
    function nonfungiblePositionManager() external view returns (address);
    function weth() external view returns (address);
    function lpLocker() external view returns (address);
    function feeAddress() external view returns (address);
    function minTotalEther() external view returns (uint256);
    function creatorFeePercent() external view returns (uint256);
    function tokenCreators(address) external view returns (address);
    function tokenPools(address) external view returns (uint256);
    function tokenInfoHashes(address) external view returns (string memory);
    function create(
        string memory name,
        string memory symbol,
        uint256 totalSupply,
        uint256 totalMinter,
        uint256 totalEther,
        uint256 liquidityPercent,
        uint256 startTime,
        string memory infoHash
    ) external returns (address);
    function setLPToken(uint256 tokenId) external;
    function setFeeAddress(address payable _feeAddress) external;
    function setMinTotalEther(uint256 _minTotalEther) external;
    function setCreatorFeePercent(uint256 _creatorFeePercent) external;
    function pause() external;
    function unpause() external;
    function updateTokenInfo(
        address tokenAddress,
        string memory infoHash
    ) external;
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.26;

import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";

/// @title Non-fungible token for positions
/// @notice Wraps Uniswap V3 positions in a non-fungible token interface which allows for them to be transferred
/// and authorized.
interface INonfungiblePositionManager is IERC721Enumerable {
    /// @notice Emitted when liquidity is increased for a position NFT
    /// @dev Also emitted when a token is minted
    /// @param tokenId The ID of the token for which liquidity was increased
    /// @param liquidity The amount by which liquidity for the NFT position was increased
    /// @param amount0 The amount of token0 that was paid for the increase in liquidity
    /// @param amount1 The amount of token1 that was paid for the increase in liquidity
    event IncreaseLiquidity(
        uint256 indexed tokenId,
        uint128 liquidity,
        uint256 amount0,
        uint256 amount1
    );
    /// @notice Emitted when liquidity is decreased for a position NFT
    /// @param tokenId The ID of the token for which liquidity was decreased
    /// @param liquidity The amount by which liquidity for the NFT position was decreased
    /// @param amount0 The amount of token0 that was accounted for the decrease in liquidity
    /// @param amount1 The amount of token1 that was accounted for the decrease in liquidity
    event DecreaseLiquidity(
        uint256 indexed tokenId,
        uint128 liquidity,
        uint256 amount0,
        uint256 amount1
    );
    /// @notice Emitted when tokens are collected for a position NFT
    /// @dev The amounts reported may not be exactly equivalent to the amounts transferred, due to rounding behavior
    /// @param tokenId The ID of the token for which underlying tokens were collected
    /// @param recipient The address of the account that received the collected tokens
    /// @param amount0 The amount of token0 owed to the position that was collected
    /// @param amount1 The amount of token1 owed to the position that was collected
    event Collect(
        uint256 indexed tokenId,
        address recipient,
        uint256 amount0,
        uint256 amount1
    );

    /// @notice Returns the position information associated with a given token ID.
    /// @dev Throws if the token ID is not valid.
    /// @param tokenId The ID of the token that represents the position
    /// @return token0 The address of the token0 for a specific pool
    /// @return token1 The address of the token1 for a specific pool
    /// @return tickSpacing The fee associated with the pool
    /// @return tickLower The lower end of the tick range for the position
    /// @return tickUpper The higher end of the tick range for the position
    /// @return liquidity The liquidity of the position
    /// @return feeGrowthInside0LastX128 The fee growth of token0 as of the last action on the individual position
    /// @return feeGrowthInside1LastX128 The fee growth of token1 as of the last action on the individual position
    /// @return tokensOwed0 The uncollected amount of token0 owed to the position as of the last computation
    /// @return tokensOwed1 The uncollected amount of token1 owed to the position as of the last computation
    function positions(
        uint256 tokenId
    )
        external
        view
        returns (
            address token0,
            address token1,
            int24 tickSpacing,
            int24 tickLower,
            int24 tickUpper,
            uint128 liquidity,
            uint256 feeGrowthInside0LastX128,
            uint256 feeGrowthInside1LastX128,
            uint128 tokensOwed0,
            uint128 tokensOwed1
        );

    struct MintParams {
        address token0;
        address token1;
        int24 tickSpacing;
        int24 tickLower;
        int24 tickUpper;
        uint256 amount0Desired;
        uint256 amount1Desired;
        uint256 amount0Min;
        uint256 amount1Min;
        address recipient;
        uint256 deadline;
    }

    /// @notice Creates a new position wrapped in a NFT
    /// @dev Call this when the pool does exist and is initialized. Note that if the pool is created but not initialized
    /// a method does not exist, i.e. the pool is assumed to be initialized.
    /// @param params The params necessary to mint a position, encoded as `MintParams` in calldata
    /// @return tokenId The ID of the token that represents the minted position
    /// @return liquidity The amount of liquidity for this position
    /// @return amount0 The amount of token0
    /// @return amount1 The amount of token1
    function mint(
        MintParams calldata params
    )
        external
        payable
        returns (
            uint256 tokenId,
            uint128 liquidity,
            uint256 amount0,
            uint256 amount1
        );

    struct IncreaseLiquidityParams {
        uint256 tokenId;
        uint256 amount0Desired;
        uint256 amount1Desired;
        uint256 amount0Min;
        uint256 amount1Min;
        uint256 deadline;
    }

    /// @notice Increases the amount of liquidity in a position, with tokens paid by the `msg.sender`
    /// @param params tokenId The ID of the token for which liquidity is being increased,
    /// amount0Desired The desired amount of token0 to be spent,
    /// amount1Desired The desired amount of token1 to be spent,
    /// amount0Min The minimum amount of token0 to spend, which serves as a slippage check,
    /// amount1Min The minimum amount of token1 to spend, which serves as a slippage check,
    /// deadline The time by which the transaction must be included to effect the change
    /// @return liquidity The new liquidity amount as a result of the increase
    /// @return amount0 The amount of token0 to acheive resulting liquidity
    /// @return amount1 The amount of token1 to acheive resulting liquidity
    function increaseLiquidity(
        IncreaseLiquidityParams calldata params
    )
        external
        payable
        returns (uint128 liquidity, uint256 amount0, uint256 amount1);

    struct DecreaseLiquidityParams {
        uint256 tokenId;
        uint128 liquidity;
        uint256 amount0Min;
        uint256 amount1Min;
        uint256 deadline;
    }

    /// @notice Decreases the amount of liquidity in a position and accounts it to the position
    /// @param params tokenId The ID of the token for which liquidity is being decreased,
    /// amount The amount by which liquidity will be decreased,
    /// amount0Min The minimum amount of token0 that should be accounted for the burned liquidity,
    /// amount1Min The minimum amount of token1 that should be accounted for the burned liquidity,
    /// deadline The time by which the transaction must be included to effect the change
    /// @return amount0 The amount of token0 accounted to the position's tokens owed
    /// @return amount1 The amount of token1 accounted to the position's tokens owed
    function decreaseLiquidity(
        DecreaseLiquidityParams calldata params
    ) external payable returns (uint256 amount0, uint256 amount1);

    struct CollectParams {
        uint256 tokenId;
        address recipient;
        uint128 amount0Max;
        uint128 amount1Max;
    }

    /// @notice Collects up to a maximum amount of fees owed to a specific position to the recipient
    /// @param params tokenId The ID of the NFT for which tokens are being collected,
    /// recipient The account that should receive the tokens,
    /// amount0Max The maximum amount of token0 to collect,
    /// amount1Max The maximum amount of token1 to collect
    /// @return amount0 The amount of fees collected in token0
    /// @return amount1 The amount of fees collected in token1
    function collect(
        CollectParams calldata params
    ) external payable returns (uint256 amount0, uint256 amount1);

    /// @notice Burns a token ID, which deletes it from the NFT contract. The token must have 0 liquidity and all tokens
    /// must be collected first.
    /// @param tokenId The ID of the token that is being burned
    function burn(uint256 tokenId) external payable;
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.26;

/// @title The interface for the Uniswap V3 Factory
interface IUniswapV3Factory {
    /// @notice Creates a pool for the given two tokens and fee
    /// @param tokenA One of the two tokens in the desired pool
    /// @param tokenB The other of the two tokens in the desired pool
    /// @param tickSpacing The desired fee for the pool
    /// @dev tokenA and tokenB may be passed in either order: token0/token1 or token1/token0. tickSpacing is retrieved
    /// from the fee. The call will revert if the pool already exists, the fee is invalid, or the token arguments
    /// are invalid.
    /// @return pool The address of the newly created pool
    function createPool(
        address tokenA,
        address tokenB,
        int24 tickSpacing,
        uint160 sqrtPriceLimitX96
    ) external returns (address pool);

    /// @notice Returns the pool address for a given pair of tokens and a fee, or address 0 if it does not exist
    /// @dev tokenA and tokenB may be passed in either token0/token1 or token1/token0 order
    /// @param tokenA The contract address of either token0 or token1
    /// @param tokenB The contract address of the other token
    /// @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip
    /// @return pool The pool address
    function getPool(
        address tokenA,
        address tokenB,
        uint24 fee
    ) external view returns (address pool);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.26;

/// @title The interface for a Uniswap V3 Pool
interface IUniswapV3Pool {
    function initialize(uint160 sqrtPriceX96) external;
    function token0() external view returns (address);
    function token1() external view returns (address);
    function fee() external view returns (uint24);
    function slot0()
        external
        view
        returns (
            uint160 sqrtPriceX96,
            int24 tick,
            uint16 observationIndex,
            uint16 observationCardinality,
            uint16 observationCardinalityNext,
            uint8 feeProtocol,
            bool unlocked
        );
    function ticks(
        int24 tick
    )
        external
        view
        returns (
            uint128 liquidityGross,
            int128 liquidityNet,
            uint256 feeGrowthOutside0X128,
            uint256 feeGrowthOutside1X128,
            int56 tickCumulativeOutside,
            uint160 secondsPerLiquidityOutsideX128,
            uint32 secondsOutside,
            bool initialized
        );
    function feeGrowthGlobal0X128() external view returns (uint256);

    function feeGrowthGlobal1X128() external view returns (uint256);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.26;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
    function deposit() external payable;
    function withdraw(uint256) external;
}

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

contract FeeMRegister {
    /// @dev Register my contract on Sonic FeeM
    function registerMe() internal {
        (bool _success, ) = address(0xDC2B0D2Dd2b7759D97D50db4eabDC36973110830)
            .call(abi.encodeWithSignature("selfRegister(uint256)", 105));
        require(_success, "FeeM registration failed");
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.26;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

library TransferHelper {
    /// @notice Transfers tokens from the targeted address to the given destination
    /// @notice Errors with 'STF' if transfer fails
    /// @param token The contract address of the token to be transferred
    /// @param from The originating address from which the tokens will be transferred
    /// @param to The destination address of the transfer
    /// @param value The amount to be transferred
    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSelector(
                IERC20.transferFrom.selector,
                from,
                to,
                value
            )
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "STF"
        );
    }

    /// @notice Transfers tokens from msg.sender to a recipient
    /// @dev Errors with ST if transfer fails
    /// @param token The contract address of the token which will be transferred
    /// @param to The recipient of the transfer
    /// @param value The value of the transfer
    function safeTransfer(address token, address to, uint256 value) internal {
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSelector(IERC20.transfer.selector, to, value)
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "ST"
        );
    }

    /// @notice Approves the stipulated contract to spend the given allowance in the given token
    /// @dev Errors with 'SA' if transfer fails
    /// @param token The contract address of the token to be approved
    /// @param to The target of the approval
    /// @param value The amount of the given token the target will be allowed to spend
    function safeApprove(address token, address to, uint256 value) internal {
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSelector(IERC20.approve.selector, to, value)
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "SA"
        );
    }

    /// @notice Transfers ETH to the recipient address
    /// @dev Fails with `STE`
    /// @param to The destination of the transfer
    /// @param value The value to be transferred
    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, "STE");
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "viaIR": true,
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint256","name":"totalSupply","type":"uint256"},{"internalType":"uint256","name":"totalMinter","type":"uint256"},{"internalType":"uint256","name":"totalEther","type":"uint256"},{"internalType":"uint256","name":"liquidityPercent","type":"uint256"},{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"address","name":"factoryAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","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":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"creator","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"CreatorFeePaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"creator","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"CreatorFeeTransferFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"poolAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethAmount","type":"uint256"},{"indexed":false,"internalType":"uint128","name":"liquidity","type":"uint128"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"LiquidityAddedV3","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"etherAmount","type":"uint256"}],"name":"Refunded","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":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[],"name":"TransfersUnlocked","type":"event"},{"inputs":[],"name":"VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"addLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"etherPerMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"contract IFactory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lpLocker","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintAmountPerAddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nonfungiblePositionManager","outputs":[{"internalType":"contract INonfungiblePositionManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"poolAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"refund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"transfersLocked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

00000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000e8d4a5100000000000000000000000000000000000000000000000000000000000000007d000000000000000000000000000000000000000000000043c33c1937564800000000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000000000000000000000000000008e11537e75c11677ea40fb91ebd2439768c9b8f0000000000000000000000000000000000000000000000000000000000000000a536d696c65204d696e74000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003532e4d0000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): Smile Mint
Arg [1] : symbol (string): S.M
Arg [2] : totalSupply (uint256): 1000000000000
Arg [3] : totalMinter (uint256): 2000
Arg [4] : totalEther (uint256): 20000000000000000000000
Arg [5] : liquidityPercent (uint256): 20
Arg [6] : startTime (uint256): 0
Arg [7] : factoryAddress (address): 0x8e11537E75c11677ea40Fb91EBD2439768c9B8F0

-----Encoded View---------------
12 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000140
Arg [2] : 000000000000000000000000000000000000000000000000000000e8d4a51000
Arg [3] : 00000000000000000000000000000000000000000000000000000000000007d0
Arg [4] : 00000000000000000000000000000000000000000000043c33c1937564800000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000014
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000008e11537e75c11677ea40fb91ebd2439768c9b8f0
Arg [8] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [9] : 536d696c65204d696e7400000000000000000000000000000000000000000000
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [11] : 532e4d0000000000000000000000000000000000000000000000000000000000