// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

import "@const/Constants.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {wdiv, wmul, sub, wpow, sqrt} from "@utils/Math.sol";
import {AscendantPride} from "@core/AscendantPride.sol";
import {FullMath} from "v3-core/contracts/libraries/FullMath.sol";
import {AscendantAuction} from "./AscendantAuction.sol";
import {AscendantBuyAndBurn} from "./AscendantBuyAndBurn.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IUniswapV3Pool} from "v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import {IQuoter} from "@uniswap/v3-periphery/contracts/interfaces/IQuoter.sol";
import {Ownable2Step, Ownable} from "@openzeppelin/contracts/access/Ownable2Step.sol";
import {ERC20Burnable} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import {INonfungiblePositionManager} from "@uniswap/v3-periphery/contracts/interfaces/INonfungiblePositionManager.sol";

/**
 * @title Ascendant Token Contract
 * @author Decentra
 * @notice Implementation of a hyper-deflationary token with Uniswap V3 integration and DragonX ecosystem rewards
 * @dev Contract inherits ERC20Burnable for token burns and Ownable2Step for secure ownership management
 *      Integrates with:
 *      - Uniswap V3 for primary liquidity pool (DragonX/Ascendant pair)
 *      - AscendantAuction for daily token distributions
 *      - AscendantPride for post-day-10 auction mechanics
 *      - AscendantBuyAndBurn for deflationary mechanisms
 *      Features:
 *      - Fixed max supply of 1.155B tokens
 *      - Initial liquidity of 5M tokens
 *      - Daily auctions for first 10 days
 *      - Automated buy-and-burn mechanism
 *      - DragonX ecosystem rewards distribution
 */
contract Ascendant is ERC20Burnable, Ownable2Step {
    using FullMath for uint256;

    /* ==== IMMUTABLES ==== */

    /**
     * @notice The immutable address of the Uniswap V3 pool for DragonX/Ascendant pair
     */
    address public immutable dragonXAscendantPool;

    /* ==== STATE ==== */

    /**
     * @notice The auction contract responsible for daily token distributions
     */
    AscendantAuction public auction;

    /**
     * @notice The buy and burn contract that manages token burning mechanics
     */
    AscendantBuyAndBurn public buyAndBurn;

    /**
     * @notice The pride contract that manages tokens for future auctions after day 10
     */
    AscendantPride public ascendantPride;

    /* ==== ERRORS ==== */

    error OnlyAuction();

    /* ==== CONSTRUCTOR ==== */

    /**
     * @notice Initializes the Ascendant token and creates the initial DragonX/Ascendant liquidity pool
     * @dev Sets up initial token supply and creates Uniswap V3 pool for DragonX/Ascendant pair
     * @param _titanX Address of the TitanX token contract used for minting and auctions
     * @param _dragonX Address of the DragonX token contract for liquidity pairing
     * @param _quoter Address of the Uniswap V3 Quoter contract for price calculations
     * @param _uniswapV3PositionManager Address of the Uniswap V3 NonfungiblePositionManager
     */
    constructor(address _titanX, address _dragonX, address _quoter, address _uniswapV3PositionManager)
        payable
        ERC20("Ascendant.win", "Ascend")
        Ownable(msg.sender)
    {
        _mint(LIQUIDITY_BONDING, 50_000_000e18);
        _mint(msg.sender, INITIAL_TO_ASCENDANT_PRIDE);
        dragonXAscendantPool = _createUniswapV3Pool(_titanX, _dragonX, _quoter, _uniswapV3PositionManager);
    }

    //==========================//
    //=========MODIFIERS========//
    //==========================//

    /**
     * @dev Modifier to ensure the function is called only by the Auction contract.
     *      Uses _onlyAuction() instead of inline check for gas optimization.
     */
    modifier onlyAuction() {
        _onlyAuction();
        _;
    }

    //==========================//
    //=========EXTERNAL=========//
    //==========================//

    /**
     * @notice Sets the address of the AscendantAuction contract
     * @dev Updates both the auction contract reference and retrieves the associated pride contract
     * @param _ascendantAuction Address of the new auction contract
     */
    function setAscendantAuction(address payable _ascendantAuction) external onlyOwner {
        auction = AscendantAuction(_ascendantAuction);
        ascendantPride = auction.ascendantPride();
    }

    /**
     * @notice Sets the address of the AscendantBuyAndBurn contract
     * @dev Updates the contract reference for the buy and burn mechanism
     * @param _ascendantBuyAndBurn Address of the new buy and burn contract
     */
    function setAscendantBuyAndBurn(address _ascendantBuyAndBurn) external onlyOwner {
        buyAndBurn = AscendantBuyAndBurn(_ascendantBuyAndBurn);
    }

    /**
     * @notice Mints daily auction tokens
     * @dev Mints AUCTION_EMIT amount of tokens to the auction contract
     * @return emitted Amount of tokens minted for the auction
     */
    function emitForAuction() external onlyAuction returns (uint256 emitted) {
        emitted = AUCTION_EMIT;

        _mint(address(auction), emitted);
    }

    /**
     * @notice Mints initial liquidity tokens
     * @dev Mints INITIAL_ASCENDANT_FOR_LP tokens to the auction contract for LP formation
     * @return emitted Amount of tokens minted for initial liquidity
     */
    function emitForLp() external onlyAuction returns (uint256 emitted) {
        emitted = INITIAL_ASCENDANT_FOR_LP;

        _mint(address(auction), emitted);
    }

    //==========================//
    //=========INTERNAL=========//
    //==========================//

    /**
     * @dev Private method is used instead of inlining into modifier because modifiers are copied into each method,
     *      and the use of immutable means the address bytes are copied in every place the modifier is used.
     */
    function _onlyAuction() internal view {
        if (msg.sender != address(auction)) revert OnlyAuction();
    }

    /**
     * @notice Creates and initializes a Uniswap V3 pool for DragonX/Ascendant pair
     * @dev Sets up initial liquidity ratio and configures pool parameters.
     * @param _titanX Address of the TitanX token used to calculate initial DragonX amount
     * @param _dragonX Address of the DragonX token for pool pairing
     * @param UNISWAP_V3_QUOTER Address of Uniswap V3 Quoter contract for price calculations
     * @param UNISWAP_V3_POSITION_MANAGER Address of Uniswap V3 NonfungiblePositionManager
     * @return _pool Address of the newly created Uniswap V3 pool
     */
    function _createUniswapV3Pool(
        address _titanX,
        address _dragonX,
        address UNISWAP_V3_QUOTER,
        address UNISWAP_V3_POSITION_MANAGER
    ) internal returns (address _pool) {
        address _ascendant = address(this);

        IQuoter quoter = IQuoter(UNISWAP_V3_QUOTER);

        bytes memory path = abi.encodePacked(address(_titanX), POOL_FEE, address(_dragonX));

        uint256 dragonXAmount = quoter.quoteExactInput(path, INITIAL_TITAN_X_FOR_LIQ);

        uint256 ascendantAmount = INITIAL_ASCENDANT_FOR_LP;

        (address token0, address token1) = _ascendant < _dragonX ? (_ascendant, _dragonX) : (_dragonX, _ascendant);

        (uint256 amount0, uint256 amount1) =
            token0 == _dragonX ? (dragonXAmount, ascendantAmount) : (ascendantAmount, dragonXAmount);

        uint160 sqrtPX96 = uint160((sqrt((amount1 * 1e18) / amount0) * 2 ** 96) / 1e9);

        INonfungiblePositionManager manager = INonfungiblePositionManager(UNISWAP_V3_POSITION_MANAGER);

        _pool = manager.createAndInitializePoolIfNecessary(token0, token1, POOL_FEE, sqrtPX96);

        IUniswapV3Pool(_pool).increaseObservationCardinalityNext(uint16(200));
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

import "@utils/Errors.sol";
import "@const/Constants.sol";
import {Time} from "@utils/Time.sol";
import {IWETH9} from "@interfaces/IWETH.sol";
import {Ascendant} from "@core/Ascendant.sol";
import {AscendantPride} from "@core/AscendantPride.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {AscendantBuyAndBurn} from "@core/AscendantBuyAndBurn.sol";
import {wmul} from "@utils/Math.sol";
import {TickMath} from "@uniswap/v3-core/contracts/libraries/TickMath.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SwapActions, SwapActionParams} from "@actions/SwapActions.sol";
import {IAscendant, IAscendantBuyAndBurn} from "@interfaces/IAscendant.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ERC20Burnable} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import {INonfungiblePositionManager} from "@uniswap/v3-periphery/contracts/interfaces/INonfungiblePositionManager.sol";

/**
 * @dev Struct representing Uniswap V3 Liquidity Position details
 * @param hasLP Boolean indicating if liquidity has been added
 * @param isAscendantToken0 Boolean indicating if Ascendant is token0 in the pair
 * @param tokenId Uniswap V3 NFT position ID
 */
struct LP {
    bool hasLP;
    bool isAscendantToken0;
    uint256 tokenId;
}

/**
 * @dev Struct tracking daily auction statistics
 * @param ascendantEmitted Amount of Ascendant tokens emitted for the day
 * @param titanXDeposited Total TitanX tokens deposited for the day
 */
struct DailyStatistic {
    uint256 ascendantEmitted;
    uint256 titanXDeposited;
}

/**
 * @title AscendantAuction
 * @author Decentra
 * @dev Contract managing the auction of Ascendant tokens through TitanX deposits
 *      and subsequent liquidity management in Uniswap V3.
 *
 * @notice This contract:
 *         - Manages daily auctions for Ascendant tokens
 *         - Handles TitanX and ETH deposits
 *         - Manages Uniswap V3 liquidity
 *         - Processes fee collection and distribution
 *         - Tracks daily statistics and user deposits
 */
contract AscendantAuction is SwapActions {
    using SafeERC20 for IERC20;
    using SafeERC20 for IAscendant;
    using Math for uint256;

    /* == IMMUTABLES == */

    IAscendant immutable ascendant; // Ascendant token contract
    IERC20 public immutable titanX; // TitanX token contract
    IERC20 public immutable dragonX; // DragonX token contract
    IWETH9 public immutable weth; // Wrapped ETH contract
    uint32 public immutable startTimestamp;
    address public immutable tincBnB;
    address public immutable uniswapV3PositionManager;

    /* == STATE == */
    uint256 public totalTitanXDeposited;
    uint128 lpSlippage = WAD - 0.2e18; // Liquidity provision slippage tolerance (default: WAD - 0.2e18)

    LP public lp;
    AscendantPride public immutable ascendantPride;

    /**
     * @notice Mapping for user deposits and daily statistics
     */
    mapping(address => mapping(uint32 day => uint256 amount)) public depositOf;
    mapping(uint32 day => DailyStatistic) public dailyStats;

    /* == ERRORS == */
    error AscendantAuction__InvalidInput();
    error AscendantAuction__OnlyClaimableTheNextDay();
    error AscendantAuction__LiquidityAlreadyAdded();
    error AscendantAuction__NotStartedYet();
    error AscendantAuction__NothingToClaim();
    error AscendantAuction__InvalidSlippage();
    error AscendantAuction__NotEnoughTitanXForLiquidity();
    error AscendantAuction__TreasuryAscendantIsEmpty();

    /* == EVENTS === */

    event Deposit(address indexed user, uint256 indexed titanXAmount, uint32 indexed day);
    event UserClaimed(address indexed user, uint256 indexed ascendantAmount, uint32 indexed day);

    /* == CONSTRUCTOR == */
    /**
     * @notice Constructor for AscendantAuction
     * @dev Initializes core contract references and auction parameters
     * @param _ascendant Address of the Ascendant token contract
     * @param _dragonX Address of the DragonX token contract
     * @param _titanX Address of the TitanX token contract
     * @param _weth Address of the WETH contract
     * @param _tincBnB Address of the TincBnB contract
     * @param _uniswapV3PositionManager Address of Uniswap V3 position manager
     * @param _params SwapActions initialization parameters
     * @param _startTimestamp Timestamp when the auction starts
     */
    constructor(
        address _ascendant,
        address _dragonX,
        address _titanX,
        address _weth,
        address _tincBnB,
        address _uniswapV3PositionManager,
        SwapActionParams memory _params,
        uint32 _startTimestamp
    )
        payable
        SwapActions(_params)
        notAddress0(_ascendant)
        notAddress0(_dragonX)
        notAddress0(_titanX)
        notAddress0(_weth)
        notAddress0(_tincBnB)
        notAddress0(_uniswapV3PositionManager)
    {
        // nftCollection address
        ascendant = IAscendant(_ascendant);
        dragonX = IERC20(_dragonX);
        titanX = IERC20(_titanX);
        weth = IWETH9(_weth);
        tincBnB = _tincBnB;
        ascendantPride = new AscendantPride(address(this), _ascendant);
        uniswapV3PositionManager = _uniswapV3PositionManager;
        startTimestamp = _startTimestamp;
    }

    //==========================//
    //==========PUBLIC==========//
    //==========================//

    /**
     * @notice Claims Ascendant tokens for a specific day
     * @param _day The day to claim tokens for
     */
    function claim(uint32 _day) public {
        uint32 daySinceStart = Time.daysSince(startTimestamp) + 1;
        if (_day == daySinceStart) revert AscendantAuction__OnlyClaimableTheNextDay();

        uint256 toClaim = amountToClaim(msg.sender, _day);

        if (toClaim == 0) revert AscendantAuction__NothingToClaim();

        emit UserClaimed(msg.sender, toClaim, _day);

        ascendant.safeTransfer(msg.sender, toClaim);

        depositOf[msg.sender][_day] = 0;
    }

    /**
     * @notice Calculates claimable Ascendant tokens for a user on a specific day
     * @param _user Address of the user
     * @param _day Day to check
     * @return toClaim Amount of Ascendant tokens claimable
     */
    function amountToClaim(address _user, uint32 _day) public view returns (uint256 toClaim) {
        uint256 depositAmount = depositOf[_user][_day];
        DailyStatistic memory stats = dailyStats[_day];

        return (depositAmount * stats.ascendantEmitted) / stats.titanXDeposited;
    }

    /**
     * @notice Calculates total claimable Ascendant tokens for a user across multiple days
     * @dev Sums up all claimable amounts for the specified days
     * @param _user Address of the user to check
     * @param _days Array of days to check for claimable amounts
     * @return toClaim Total amount of Ascendant tokens claimable across all specified days
     */
    function batchClaimableAmount(address _user, uint32[] calldata _days) public view returns (uint256 toClaim) {
        for (uint256 i; i < _days.length; ++i) {
            toClaim += amountToClaim(_user, _days[i]);
        }
    }

    //==========================//
    //=========EXTERNAL=========//
    //==========================//

    /**
     * @notice Updates LP slippage tolerance
     * @param _newSlippage New slippage value
     */
    function changeLPSlippage(uint128 _newSlippage) external onlyOwner notAmount0(_newSlippage) {
        if (_newSlippage > WAD) revert AscendantAuction__InvalidSlippage();
        lpSlippage = _newSlippage;
    }

    /**
     * @notice Batch claims Ascendant tokens for multiple days at once
     * @dev Executes claim function for each specified day
     * @param _days Array of days to claim tokens for
     */
    function batchClaim(uint32[] calldata _days) external {
        for (uint256 i; i < _days.length; ++i) {
            claim(_days[i]);
        }
    }

    /**
     * @notice Deposits TitanX tokens for auction participation
     * @param _amount Amount of TitanX to deposit
     */
    function depositTitanX(uint256 _amount) external {
        if (_amount == 0) revert AscendantAuction__InvalidInput();

        if (startTimestamp > Time.blockTs()) revert AscendantAuction__NotStartedYet();

        _updateAuction();

        uint32 daySinceStart = Time.daysSince(startTimestamp) + 1;

        DailyStatistic storage stats = dailyStats[daySinceStart];

        titanX.transferFrom(msg.sender, address(this), _amount);

        _deposit(_amount);

        depositOf[msg.sender][daySinceStart] += _amount;

        stats.titanXDeposited += _amount;
        totalTitanXDeposited += _amount;

        emit Deposit(msg.sender, _amount, daySinceStart);
    }

    /**
     * @notice Deposits ETH which is converted to TitanX for auction participation
     * @dev Converts ETH to WETH, then swaps for TitanX using Uniswap
     * @param _amountTitanXMin Minimum amount of TitanX to receive after swap
     * @param _deadline Deadline for the swap transaction
     */
    function depositETH(uint256 _amountTitanXMin, uint32 _deadline) external payable notExpired(_deadline) {
        if (msg.value == 0) revert AscendantAuction__InvalidInput();

        if (startTimestamp > Time.blockTs()) revert AscendantAuction__NotStartedYet();

        _updateAuction();

        weth.deposit{value: msg.value}();

        uint256 titanXAmount = swapExactInput(address(weth), address(titanX), msg.value, _amountTitanXMin, _deadline);

        uint32 daySinceStart = Time.daysSince(startTimestamp) + 1;

        DailyStatistic storage stats = dailyStats[daySinceStart];

        _deposit(titanXAmount);

        depositOf[msg.sender][daySinceStart] += titanXAmount;

        stats.titanXDeposited += titanXAmount;
        totalTitanXDeposited += titanXAmount;

        emit Deposit(msg.sender, titanXAmount, daySinceStart);
    }

    /**
     * @notice Creates and adds initial liquidity to Uniswap V3 pool
     * @dev Only owner can call this once
     * @param _deadline Deadline for the liquidity addition
     */
    function addLiquidityToAscendantDragonXPool(uint32 _deadline) external onlyOwner notExpired(_deadline) {
        if (lp.hasLP) revert AscendantAuction__LiquidityAlreadyAdded();

        if (titanX.balanceOf(address(this)) < INITIAL_TITAN_X_FOR_LIQ) {
            revert AscendantAuction__NotEnoughTitanXForLiquidity();
        }

        uint256 _excessAmount = titanX.balanceOf(address(this)) - INITIAL_TITAN_X_FOR_LIQ;

        uint256 _dragonXAmount =
            swapExactInput(address(titanX), address(dragonX), INITIAL_TITAN_X_FOR_LIQ, 0, _deadline);

        ascendant.emitForLp();

        (uint256 amount0, uint256 amount1, uint256 amount0Min, uint256 amount1Min, address token0, address token1) =
            _sortAmounts(_dragonXAmount, INITIAL_ASCENDANT_FOR_LP);

        ERC20Burnable(token0).approve(uniswapV3PositionManager, amount0);
        ERC20Burnable(token1).approve(uniswapV3PositionManager, amount1);

        // wake-disable-next-line
        INonfungiblePositionManager.MintParams memory params = INonfungiblePositionManager.MintParams({
            token0: token0,
            token1: token1,
            fee: POOL_FEE,
            tickLower: (TickMath.MIN_TICK / TICK_SPACING) * TICK_SPACING,
            tickUpper: (TickMath.MAX_TICK / TICK_SPACING) * TICK_SPACING,
            amount0Desired: amount0,
            amount1Desired: amount1,
            amount0Min: amount0Min,
            amount1Min: amount1Min,
            recipient: address(this),
            deadline: _deadline
        });

        // wake-disable-next-line
        (uint256 tokenId,,,) = INonfungiblePositionManager(uniswapV3PositionManager).mint(params);

        bool isAscendantToken0 = token0 == address(ascendant);

        lp = LP({hasLP: true, tokenId: tokenId, isAscendantToken0: isAscendantToken0});

        if (_excessAmount > 0) {
            titanX.transfer(owner(), _excessAmount);
        }

        _transferOwnership(address(0));
    }

    /**
     * @notice Collects the accrued fees from the UniswapV3 position
     * @return amount0 The amount of token0 collected
     * @return amount1 The amount of token1 collected
     */
    function collectFees() external returns (uint256 amount0, uint256 amount1) {
        LP memory _lp = lp;

        INonfungiblePositionManager.CollectParams memory params = INonfungiblePositionManager.CollectParams({
            tokenId: _lp.tokenId,
            recipient: address(this),
            amount0Max: type(uint128).max,
            amount1Max: type(uint128).max
        });

        (amount0, amount1) = INonfungiblePositionManager(uniswapV3PositionManager).collect(params);

        (uint256 ascendantAmount, uint256 dragonXAmount) =
            _lp.isAscendantToken0 ? (amount0, amount1) : (amount1, amount0);

        dragonX.transfer(LIQUIDITY_BONDING, dragonXAmount);

        sendToGenesisWallets(ascendant, ascendantAmount);
    }

    //==========================//
    //=========INTERNAL=========//
    //==========================//

    /**
     * @dev Internal function to distribute deposited TitanX tokens
     * @param _amount Amount of TitanX to distribute
     */
    function _deposit(uint256 _amount) internal {
        //@note - If there is no added liquidity, but the balance exceeds the initial for liquidity, we should distribute the difference
        if (!lp.hasLP) {
            uint256 titanXBalance = titanX.balanceOf(address(this));

            if (titanXBalance <= INITIAL_TITAN_X_FOR_LIQ) return;

            _amount = titanXBalance - INITIAL_TITAN_X_FOR_LIQ;
        }

        uint256 titanXLPTax = wmul(_amount, TITAN_X_LP_TAX);

        _amount -= titanXLPTax;

        uint256 titanXToConvertToDragonX = wmul(_amount, TITANX_TO_DRAGONX_RATIO);
        uint256 titanXToSendToTincBnB = wmul(_amount, TITANX_TO_TINC_RATIO);
        uint256 titanXToSendToGenesisWallet = wmul(_amount, GENESIS);

        titanX.safeTransfer(LIQUIDITY_BONDING, titanXLPTax); // 1% titanX send to the LP

        IAscendantBuyAndBurn bnb = ascendant.buyAndBurn();

        titanX.approve(address(bnb), titanXToConvertToDragonX); // 72% of that is approved to the ascendant BnB

        bnb.distributeTitanXForBurning(titanXToConvertToDragonX);

        titanX.safeTransfer(tincBnB, titanXToSendToTincBnB); // 20% titanX send to dragonX TINC BnB

        sendToGenesisWallets(titanX, titanXToSendToGenesisWallet); // 8% titanX send to genesis wallets
    }

    /**
     * @dev Updates the auction state for the current day
     * @notice Handles Ascendant token emission for the current auction day
     */
    function _updateAuction() internal {
        uint32 daySinceStart = Time.daysSince(startTimestamp) + 1;

        if (dailyStats[daySinceStart].ascendantEmitted != 0) return;

        if (daySinceStart > DAY_10 && ascendant.balanceOf(address(ascendantPride)) == 0) {
            revert AscendantAuction__TreasuryAscendantIsEmpty();
        }

        uint256 emitted = (daySinceStart <= DAY_10) ? ascendant.emitForAuction() : ascendantPride.emitForAuction();

        dailyStats[daySinceStart].ascendantEmitted = emitted;
    }

    /**
     * @dev Sorts token amounts for liquidity provision
     * @param _dragonXAmount Amount of DragonX tokens
     * @param _ascendantAmount Amount of Ascendant tokens
     * @return amount0 Amount of token0
     * @return amount1 Amount of token1
     * @return amount0Min Minimum amount of token0 accounting for slippage
     * @return amount1Min Minimum amount of token1 accounting for slippage
     * @return token0 Address of token0 (lower address between Ascendant and DragonX)
     * @return token1 Address of token1 (higher address between Ascendant and DragonX)
     */
    function _sortAmounts(uint256 _dragonXAmount, uint256 _ascendantAmount)
        internal
        view
        returns (
            uint256 amount0,
            uint256 amount1,
            uint256 amount0Min,
            uint256 amount1Min,
            address token0,
            address token1
        )
    {
        address _ascendant = address(ascendant);
        address _dragonX = address(dragonX);

        (token0, token1) = _ascendant < _dragonX ? (_ascendant, _dragonX) : (_dragonX, _ascendant);
        (amount0, amount1) =
            token0 == _ascendant ? (_ascendantAmount, _dragonXAmount) : (_dragonXAmount, _ascendantAmount);

        (amount0Min, amount1Min) = (wmul(amount0, lpSlippage), wmul(amount1, lpSlippage));
    }

    //==========================//
    //==========PRIVATE=========//
    //==========================//

    function sendToGenesisWallets(IERC20 erc20Token, uint256 _amount) private {
        uint256 genesisHalf = wmul(_amount, HALF);

        erc20Token.safeTransfer(GENESIS_WALLET_1, genesisHalf);
        erc20Token.safeTransfer(GENESIS_WALLET_2, genesisHalf);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.27;

import "@const/Constants.sol";
import {Time} from "@utils/Time.sol";
import {Ascendant} from "@core/Ascendant.sol";
import {AscendantPride} from "@core/AscendantPride.sol";
import {IAscendant} from "@interfaces/IAscendant.sol";
import {wmul} from "@utils/Math.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {AscendantNFTMinting} from "@core/AscendantNFTMinting.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SwapActions, SwapActionParams} from "@actions/SwapActions.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ERC20Burnable} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";

/**
 * @title AscendantBuyAndBurn
 * @author Decentra
 * @notice This contract manages the automated buying and burning of Ascendant tokens using DragonX through Uniswap V3 pools
 * @dev Inherits from SwapActions to handle Uniswap V3 swap functionality
 */
contract AscendantBuyAndBurn is SwapActions {
    using SafeERC20 for IERC20;
    using Math for uint256;

    //=============STRUCTS============//

    /**
     * @notice Represents an interval for token burning operations
     * @param amountAllocated Amount of tokens allocated for burning in this interval
     * @param amountBurned Amount of tokens that have been burned in this interval
     */
    struct Interval {
        uint128 amountAllocated;
        uint128 amountBurned;
    }

    //===========IMMUTABLE===========//

    IAscendant immutable ascendant;
    IERC20 public immutable dragonX;
    ERC20Burnable public immutable titanX;
    uint32 public immutable startTimeStamp;
    AscendantNFTMinting public immutable nftMinting;

    //===========STATE===========//

    uint256 public totalAscendantBurnt;
    uint256 public lastBurnedInterval;
    uint256 public totalTitanXDistributed;
    uint256 public currentBnBPressure;

    uint128 public swapCap;

    mapping(uint32 interval => Interval) public intervals;

    uint32 public lastIntervalNumber;
    uint32 public lastBurnedIntervalStartTimestamp;
    uint32 public lastSnapshot;

    AscendantPride public ascendantPride;

    //===========EVENTS===========//

    /**
     * @notice Emitted when tokens are bought and burned
     * @param dragonXAmount Amount of DragonX tokens used in the operation
     * @param ascendantBurnt Amount of Ascendant tokens that were burned
     * @param caller Address that initiated the buy and burn operation
     */
    event BuyAndBurn(uint256 indexed dragonXAmount, uint256 indexed ascendantBurnt, address indexed caller);

    //===========ERRORS===========//

    error AscendantBuyAndBurn__NotStartedYet();
    error AscendantBuyAndBurn__IntervalAlreadyBurned();
    error AscendantBuyAndBurn__OnlySlippageAdmin();
    error AscendantBuyAndBurn__OnlyEOA();
    error AscendantBuyAndBurn__InvalidStartTime();

    //========CONSTRUCTOR========//
    /**
     * @notice Initializes the AscendantBuyAndBurn contract with required parameters and contracts
     * @param _startTimestamp The Unix timestamp when the contract should begin operations
     * @param _dragonX The address of the DragonX ERC20 token contract
     * @param _titanX The address of the TitanX burnable token contract
     * @param _ascendant The address of the Ascendant token contract
     * @param _params Parameters for initializing the SwapActions base contract
     * @param _ascendantRecycle The AscendantPride contract address for recycling operations
     * @param _nftMinting The address of the NFT minting contract for reward distributions
     * @dev Initializes the contract with the following operations:
     * - Inherits SwapActions with provided swap parameters
     * - Verifies all address parameters are non-zero
     * - Sets initial state variables and contract references
     * - Approves NFT minting contract to spend DragonX tokens
     * - Sets initial swap cap to maximum uint128 value
     */
    constructor(
        uint32 _startTimestamp,
        address _dragonX,
        address _titanX,
        address _ascendant,
        SwapActionParams memory _params,
        AscendantPride _ascendantRecycle,
        address _nftMinting
    )
        SwapActions(_params)
        notAddress0(_ascendant)
        notAddress0(_dragonX)
        notAddress0(_titanX)
        notAddress0(address(_ascendantRecycle))
        notAddress0(_nftMinting)
    {
        require(_startTimestamp % Time.SECONDS_PER_DAY == Time.TURN_OVER_TIME, AscendantBuyAndBurn__InvalidStartTime());

        startTimeStamp = _startTimestamp;
        ascendant = IAscendant(_ascendant);
        dragonX = IERC20(_dragonX);
        titanX = ERC20Burnable(_titanX);
        nftMinting = AscendantNFTMinting(_nftMinting);
        ascendantPride = _ascendantRecycle;
        swapCap = type(uint128).max;

        dragonX.approve(address(nftMinting), type(uint256).max); // to save from fees
    }

    //========MODIFIERS=======//

    /**
     * @notice Ensures interval state is updated before executing the modified function
     * @dev Calls _intervalUpdate() before function execution and allows function to proceed
     */
    modifier intervalUpdate() {
        _intervalUpdate();
        _;
    }

    /**
     * @notice Restricts function access to the slippage admin
     * @dev Calls _onlySlippageAdmin() to verify caller before function execution
     */
    modifier onlySlippageAdmin() {
        _onlySlippageAdmin();
        _;
    }

    //==========================//
    //=========EXTERNAL=========//
    //==========================//

    /**
     * @notice Sets the maximum amount that can be swapped in a single interval
     * @param _newCap New cap value (0 sets to max uint128)
     * @dev Only callable by slippage admin
     */
    function setSwapCap(uint128 _newCap) external onlySlippageAdmin {
        swapCap = _newCap == 0 ? type(uint128).max : _newCap;
    }

    /**
     * @notice Executes the buy and burn process
     * @param _deadline Timestamp by which the transaction must be executed
     */
    function swapDragonXForAscendantAndBurn(uint32 _deadline) external intervalUpdate notExpired(_deadline) {
        if (msg.sender != tx.origin) {
            revert AscendantBuyAndBurn__OnlyEOA();
        }

        if (Time.blockTs() < startTimeStamp) revert AscendantBuyAndBurn__NotStartedYet();

        Interval storage currInterval = intervals[lastIntervalNumber];

        if (currInterval.amountBurned != 0) {
            revert AscendantBuyAndBurn__IntervalAlreadyBurned();
        }

        if (currInterval.amountAllocated > swapCap) {
            currInterval.amountAllocated = swapCap;
        }

        currInterval.amountBurned = currInterval.amountAllocated;

        uint256 incentive = wmul(currInterval.amountAllocated, INCENTIVE_FEE);

        uint256 titanXToSwapAndBurn = currInterval.amountAllocated - incentive;

        uint256 dragonXAmount = swapExactInput(address(titanX), address(dragonX), titanXToSwapAndBurn, 0, _deadline);

        uint256 dragonXToUseForAscendantBnB = wmul(dragonXAmount, DRAGONX_TO_ASCENDANT_RATIO);
        uint256 dragonXToSentToRewardPool = wmul(dragonXAmount, DRAGONX_TO_REWARD_POOL_RATIO);

        titanX.transfer(msg.sender, incentive);

        uint256 ascendantAmount =
            swapExactInput(address(dragonX), address(ascendant), dragonXToUseForAscendantBnB, 0, _deadline);

        nftMinting.distribute(dragonXToSentToRewardPool); // 20% of that is sent to the dragonX rewards pool

        uint256 ascendantToBeBurned = wmul(ascendantAmount, THIRTY_PERCENT);

        uint256 ascendantPrideForFutureAuctions = wmul(ascendantAmount, SEVENTY_PERCENT);

        ascendant.transfer(address(ascendantPride), ascendantPrideForFutureAuctions);

        burnAscendant(ascendantToBeBurned);

        lastBurnedInterval = lastIntervalNumber;

        emit BuyAndBurn(titanXToSwapAndBurn, ascendantAmount, msg.sender);
    }

    /**
     * @notice Allows external parties to provide TitanX tokens for burning
     * @param _amount Amount of TitanX tokens to distribute
     * @dev Updates intervals if necessary before accepting new tokens
     */
    function distributeTitanXForBurning(uint256 _amount) external notAmount0(_amount) {
        ///@dev - If there are some missed intervals update the accumulated allocation before depositing new DragonX

        titanX.transferFrom(msg.sender, address(this), _amount);

        if (Time.blockTs() > startTimeStamp && Time.blockTs() - lastBurnedIntervalStartTimestamp > INTERVAL_TIME) {
            _intervalUpdate();
        }
    }

    //==========================//
    //=========GETTERS==========//
    //==========================//

    /**
     * @notice Retrieves current interval information
     * @return _lastInterval Current interval number
     * @return _amountAllocated Amount allocated for current interval
     * @return _missedIntervals Number of missed intervals
     * @return _lastIntervalStartTimestamp Start of last interval
     * @return beforeCurrday Amount allocated before current day
     * @return updated Whether the interval was updated
     */
    function getCurrentInterval()
        public
        view
        returns (
            uint32 _lastInterval,
            uint128 _amountAllocated,
            uint16 _missedIntervals,
            uint32 _lastIntervalStartTimestamp,
            uint256 beforeCurrday,
            bool updated
        )
    {
        if (startTimeStamp > Time.blockTs()) return (0, 0, 0, 0, 0, false);

        uint32 startPoint = lastBurnedIntervalStartTimestamp == 0 ? startTimeStamp : lastBurnedIntervalStartTimestamp;
        uint32 timeElapseSinceLastBurn = Time.blockTs() - startPoint;

        if (lastBurnedIntervalStartTimestamp == 0 || timeElapseSinceLastBurn > INTERVAL_TIME) {
            (_lastInterval, _amountAllocated, _missedIntervals, beforeCurrday) =
                _calculateIntervals(timeElapseSinceLastBurn);
            _lastIntervalStartTimestamp = startPoint;
            _missedIntervals += timeElapseSinceLastBurn > INTERVAL_TIME && lastBurnedIntervalStartTimestamp != 0 ? 1 : 0;
            updated = true;
        }
    }

    /**
     * @notice Calculates daily TitanX allocation
     * @param t Timestamp to calculate allocation for
     * @return dailyWadAllocation Daily allocation in WAD format
     * @dev Allocation decreases linearly over first 10 days then remains constant
     */
    function getDailyTitanXAllocation(uint32 t) public view returns (uint256 dailyWadAllocation) {
        uint256 STARTING_ALOCATION = 0.42e18;
        uint256 MIN_ALOCATION = 0.15e18;
        uint256 daysSinceStart = Time.daysSinceAndFrom(startTimeStamp, t);

        dailyWadAllocation = daysSinceStart >= 10 ? MIN_ALOCATION : STARTING_ALOCATION - (daysSinceStart * 0.03e18);
    }

    //==========================//
    //=========INTERNAL=========//
    //==========================//

    /**
     * @notice Updates the contract's snapshot of TitanX distribution
     * @param deltaAmount Amount to subtract from current balance when calculating distribution
     */
    function _updateSnapshot(uint256 deltaAmount) internal {
        if (Time.blockTs() < startTimeStamp || lastSnapshot + 24 hours > Time.blockTs()) return;

        uint32 timeElapsed = Time.blockTs() - startTimeStamp;

        uint32 snapshots = timeElapsed / 24 hours;

        uint256 balance = titanX.balanceOf(address(this));

        totalTitanXDistributed = deltaAmount > balance ? 0 : balance - deltaAmount;
        lastSnapshot = startTimeStamp + (snapshots * 24 hours);
    }

    /**
     * @notice Calculates interval amounts and numbers based on elapsed time
     * @dev Processes daily allocations and handles interval transitions
     * @param timeElapsedSince Time elapsed since last update
     * @return _lastIntervalNumber The calculated last interval number
     * @return _totalAmountForInterval Total amount allocated for the interval
     * @return missedIntervals Number of intervals that were missed
     * @return beforeCurrDay Amount allocated before the current day
     */
    function _calculateIntervals(uint256 timeElapsedSince)
        internal
        view
        returns (
            uint32 _lastIntervalNumber,
            uint128 _totalAmountForInterval,
            uint16 missedIntervals,
            uint256 beforeCurrDay
        )
    {
        missedIntervals = _calculateMissedIntervals(timeElapsedSince);

        _lastIntervalNumber = lastIntervalNumber + missedIntervals + 1;

        uint32 currentDay = Time.dayCountByT(uint32(block.timestamp));

        uint32 dayOfLastInterval =
            lastBurnedIntervalStartTimestamp == 0 ? currentDay : Time.dayCountByT(lastBurnedIntervalStartTimestamp);

        if (currentDay == dayOfLastInterval) {
            uint256 dailyAllocation = wmul(totalTitanXDistributed, getDailyTitanXAllocation(Time.blockTs()));

            uint128 _amountPerInterval = uint128(dailyAllocation / INTERVALS_PER_DAY);

            uint128 additionalAmount = _amountPerInterval * missedIntervals;

            _totalAmountForInterval = additionalAmount + _amountPerInterval;
        } else {
            uint32 _lastBurnedIntervalStartTimestamp = lastBurnedIntervalStartTimestamp;

            uint32 theEndOfTheDay = Time.getDayEnd(_lastBurnedIntervalStartTimestamp);

            uint256 alreadyAllocated;

            uint256 balanceOf = titanX.balanceOf(address(this));

            while (currentDay >= dayOfLastInterval) {
                uint32 end = uint32(Time.blockTs() < theEndOfTheDay ? Time.blockTs() : theEndOfTheDay - 1);

                uint32 accumulatedIntervalsForTheDay = (end - _lastBurnedIntervalStartTimestamp) / INTERVAL_TIME;

                uint256 diff = balanceOf > alreadyAllocated ? balanceOf - alreadyAllocated : 0;

                //@note - If the day we are looping over the same day as the last interval's use the cached allocation, otherwise use the current balance
                uint256 forAllocation = Time.dayCountByT(lastBurnedIntervalStartTimestamp) == dayOfLastInterval
                    ? totalTitanXDistributed
                    : balanceOf >= alreadyAllocated + wmul(diff, getDailyTitanXAllocation(end)) ? diff : 0;

                uint256 dailyAllocation = wmul(forAllocation, getDailyTitanXAllocation(end));

                uint128 _amountPerInterval = uint128(dailyAllocation / INTERVALS_PER_DAY);

                _totalAmountForInterval += _amountPerInterval * accumulatedIntervalsForTheDay;

                ///@notice ->  minus 15 minutes since, at the end of the day the new epoch with new allocation
                _lastBurnedIntervalStartTimestamp = theEndOfTheDay - INTERVAL_TIME;

                ///@notice ->  plus 15 minutes to flip into the next day
                theEndOfTheDay = Time.getDayEnd(_lastBurnedIntervalStartTimestamp + INTERVAL_TIME);

                if (dayOfLastInterval == currentDay) beforeCurrDay = alreadyAllocated;

                alreadyAllocated += dayOfLastInterval == currentDay
                    ? _amountPerInterval * accumulatedIntervalsForTheDay
                    : dailyAllocation;

                dayOfLastInterval++;
            }
        }

        Interval memory prevInt = intervals[lastIntervalNumber];

        //@note - If the last interval was only updated, but not burned add its allocation to the next one.
        uint128 additional = prevInt.amountBurned == 0 ? prevInt.amountAllocated : 0;

        if (_totalAmountForInterval + additional > titanX.balanceOf(address(this))) {
            _totalAmountForInterval = uint128(titanX.balanceOf(address(this)));
        } else {
            _totalAmountForInterval += additional;
        }
    }

    /**
     * @notice Calculates the number of missed intervals
     * @dev Subtracts one from the total if lastBurnedIntervalStartTimestamp is set
     * @param timeElapsedSince Time elapsed since last update
     * @return _missedIntervals Number of intervals that were missed
     */
    function _calculateMissedIntervals(uint256 timeElapsedSince) internal view returns (uint16 _missedIntervals) {
        _missedIntervals = uint16(timeElapsedSince / INTERVAL_TIME);

        if (lastBurnedIntervalStartTimestamp != 0) _missedIntervals--;
    }

    //==========================//
    //=========PRIVATE=========//
    //==========================//

    /**
     * @notice Updates the contract state for intervals
     * @dev Updates snapshots and interval information based on current time
     */
    function _intervalUpdate() private {
        if (Time.blockTs() < startTimeStamp) revert AscendantBuyAndBurn__NotStartedYet();

        if (lastSnapshot == 0) _updateSnapshot(0);

        (
            uint32 _lastInterval,
            uint128 _amountAllocated,
            uint16 _missedIntervals,
            uint32 _lastIntervalStartTimestamp,
            uint256 beforeCurrentDay,
            bool updated
        ) = getCurrentInterval();

        _updateSnapshot(beforeCurrentDay);

        if (updated) {
            lastBurnedIntervalStartTimestamp = _lastIntervalStartTimestamp + (uint32(_missedIntervals) * INTERVAL_TIME);
            intervals[_lastInterval] = Interval({amountAllocated: _amountAllocated, amountBurned: 0});
            lastIntervalNumber = _lastInterval;
        }
    }

    /**
     * @notice Burns a specified amount of Ascendant tokens
     * @dev Updates totalAscendantBurnt and calls burn on the Ascendant token
     * @param _amount Amount of Ascendant tokens to burn
     */
    function burnAscendant(uint256 _amount) private {
        totalAscendantBurnt += _amount;
        ascendant.burn(_amount);
    }

    /**
     * @notice Checks if the caller is the slippage admin
     * @dev Reverts if the caller is not the slippage admin
     */
    function _onlySlippageAdmin() private view {
        if (msg.sender != slippageAdmin) revert AscendantBuyAndBurn__OnlySlippageAdmin();
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

import "@const/Constants.sol";
import {Time} from "@utils/Time.sol";
import {Errors} from "@utils/Errors.sol";
import {wdiv, wmul} from "@utils/Math.sol";
import {IAscendant} from "@interfaces/IAscendant.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ERC721URIStorage} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

/**
 * @title AscendantNFTMinting
 * @author Decentra
 * @notice A contract for minting, burning, and managing Ascendant NFTs with reward distribution
 * @dev Inherits from ERC721 and Errors contracts
 * Main features:
 * - NFT minting with multiple tiers
 * - Reward distribution across different time pools
 * - NFT fusion mechanism
 * - Batch operations for minting, claiming, and burning
 */
contract AscendantNFTMinting is ERC721URIStorage, Ownable, Errors {
    using SafeERC20 for IERC20;
    using Math for uint256;

    //===========STRUCTS===========//

    /**
     * @notice Record of user's NFT position and rewards
     * @param shares Amount of shares owned by the NFT
     * @param lockedAscendant Amount of Ascendant tokens locked in the NFT
     * @param rewardDebt Used to calculate correct reward distribution
     * @param startTime Timestamp when the NFT was minted
     * @param endTime Timestamp when the lock period ends
     */
    struct UserRecord {
        uint256 shares;
        uint256 lockedAscendant;
        uint256 rewardDebt;
        uint32 startTime;
        uint32 endTime;
    }

    /**
     * @notice Attributes associated with each NFT
     * @param rarityNumber Pseudo-random number generated during minting
     * @param tier NFT tier level (1-8)
     * @param NftRarity NFT rarity level (COMMON, RARE, LEGENDARY)
     */
    struct NftAttributes {
        uint256 rarityNumber;
        uint8 tier;
        Rarity rarity;
    }

    //===========ENUMS===========//

    /**
     * @notice Different reward distribution pools based on time periods
     * @param DAY8 8-day reward distribution pool
     * @param DAY28 28-day reward distribution pool
     * @param DAY90 90-day reward distribution pool
     */
    enum POOLS {
        DAY8,
        DAY28,
        DAY90
    }

    /**
     * @notice NFT Rarity levels for NFTs
     * @param COMMON Basic NFT rarity level (Tiers 1-4)
     * @param RARE Medium NFT rarity level (Tiers 5-7)
     * @param LEGENDARY Highest NFT rarity level (Tier 8)
     */
     enum Rarity {
        COMMON,
        RARE,
        LEGENDARY
    }

    //=========IMMUTABLE=========//
    IAscendant immutable ascendant;
    IERC20 immutable dragonX;

    //===========STATE===========//
    uint256 public totalShares;
    uint256 public tokenId;
    uint256 public rewardPerShare;

    uint32 public startTimestamp;
    uint32 public lastDistributedDay;

    address public ascendantPride;

    string[10][8] public tokenURIs;

    /**
     * @notice Mapping of reward pools to their pending distribution amounts
     */
    mapping(POOLS => uint256) public toDistribute;

    /**
     * @notice Mapping of token IDs to their user records
     */
    mapping(uint256 id => UserRecord record) public userRecords;

    /**
     * @notice Mapping of token IDs to their NFT attributes
     */
    mapping(uint256 => NftAttributes) public nftAttributes;

    //==========ERRORS==========//
    error AscendantMinting__FusionTokenIdsCannotBeTheSame();
    error AscendantMinting__InvalidNFTOwner();
    error AscendantMinting__InvalidTokenID(uint256 _tokenId);
    error AscendantMinting__AmountForNewMintNotReached();
    error AscendantMinting__ExpiredNFT();
    error AscendantMinting__TierOfNFTsMustBeTheSame();
    error AscendantMinting__MaxTierReached();
    error AscendantMinting__InitialLockPeriod();
    error AscendantMinting__InvalidDuration();
    error AscendantMinting__NoSharesToClaim();
    error AscendantMinting__LockPeriodNotOver();
    error AscendantMinting__OnlyMintingAndBurning();
    error AscendantMinting__InvalidNftCount();
    error AscendantMinting__MaxBatchNftThresholdReached();
    error AscendantMinting__TierAmountMismatch();
    error AscendantMinting__InvalidLegendaryTierImageIndex();

    //==========EVENTS==========//

    /**
     * @notice Emitted when a new NFT is minted
     * @param minter Address that minted the NFT
     * @param ascendant Amount of Ascendant tokens locked
     * @param id Token ID of the minted NFT
     * @param _shares Number of shares assigned to the NFT
     */
    event Minted(address indexed minter, uint256 indexed ascendant, uint256 indexed id, uint256 _shares);

    /**
     * @notice Emitted when an NFT is burned
     * @param shares Amount of shares burned
     * @param ascendantAmountReceived Amount of Ascendant tokens returned
     * @param _tokenId Token ID of the burned NFT
     * @param recepient Address receiving the Ascendant tokens
     */
    event Burnt(
        uint256 indexed shares, uint256 indexed ascendantAmountReceived, uint256 indexed _tokenId, address recepient
    );

    /**
     * @notice Emitted when an NFT is burned during fusion
     * @param shares Amount of shares fusion burned
     * @param _tokenId Token ID of the fusion burned NFT
     * @param recepient Address receiving the Ascendant tokens
     */
    event FusionBurnt(uint256 indexed shares, uint256 indexed _tokenId, address recepient);

    /**
     * @notice Event emitted when rewards are claimed for an NFT
     * @param id The token ID of the NFT
     * @param rewards Amount of rewards claimed
     * @param newRewardDebt Updated reward debt after claiming
     * @param ownerOfMint Address of the NFT owner
     */
    event Claimed(uint256 indexed id, uint256 indexed rewards, uint256 indexed newRewardDebt, address ownerOfMint);

    /**
     * @notice Event emitted when rewards are distributed to a pool
     * @param pool The pool receiving the distribution (DAY8, DAY28, or DAY90)
     * @param amount Amount of tokens distributed
     */
    event Distributed(POOLS indexed pool, uint256 indexed amount);

    /**
     * @notice Event emitted when NFT attributes are generated
     * @param tokenId The ID of the NFT
     * @param nftAttribute Random number generated for the NFT
     * @param nftTier Tier level of the NFT
     */
    event AscendantMinting__NFTAttributeGenerated(uint256 tokenId, uint256 nftAttribute, uint64 nftTier);

    /**
     * @notice Event emitted when two NFTs are fused
     * @param firstTokenId ID of the first NFT being fused
     * @param secondTokenId ID of the second NFT being fused
     * @param newTokenId ID of the newly created NFT
     * @param shares Number of shares assigned to the new NFT
     * @param oldTier Tier level of the original NFTs
     * @param newTier Tier level of the newly created NFT
     */
    event NFTFusion(
        uint256 indexed firstTokenId,
        uint256 indexed secondTokenId,
        uint256 indexed newTokenId,
        uint256 shares,
        uint8 oldTier,
        uint8 newTier
    );

    //==========CONSTRUCTOR==========//

    /**
     * @param _dragonX Address of the DragonX token contract
     * @param _ascendant Address of the Ascendant token contract
     * @param _ascendantPride Address of the AscendantPride contract
     * @param _startTimestamp Timestamp when the contract becomes operational
     */
    constructor(address _dragonX, address _ascendant, address _ascendantPride, uint32 _startTimestamp, string[10][8] memory _tokenURIs) 
        ERC721("Ascendant.win", "ASCNFT")
        Ownable(msg.sender)
    {
        startTimestamp = _startTimestamp;
        ascendant = IAscendant(_ascendant);
        dragonX = IERC20(_dragonX);
        ascendantPride = _ascendantPride;
        lastDistributedDay = 1;
        tokenURIs = _tokenURIs;
    }

    //==========================//
    //==========PUBLIC==========//
    //==========================//

    /**
    * @notice Returns metadata URI for given token ID 
    * @dev Overrides ERC721URIStorage tokenURI()
    */
    function tokenURI(uint256 _tokenId) public view override returns (string memory) {
        address owner = _ownerOf(_tokenId);
        if (owner == address(0)) {
            revert AscendantMinting__InvalidTokenID(_tokenId);
        }

        NftAttributes memory currentNftAttributes = nftAttributes[_tokenId];
    
        return tokenURIs[currentNftAttributes.tier - 1][currentNftAttributes.rarityNumber];
    }    

    /**
     * @notice Burns an NFT and returns locked Ascendant tokens
     * @param _tokenId ID of the NFT to burn
     * @param _receiver Address to receive the Ascendant tokens
     * @dev Requires lock period to be over
     */
    function burn(uint256 _tokenId, address _receiver) public notAddress0(_receiver) notAmount0(_tokenId) {
        UserRecord memory record = userRecords[_tokenId];

        if (record.shares == 0) revert AscendantMinting__NoSharesToClaim();
        if (record.endTime > Time.blockTs()) revert AscendantMinting__LockPeriodNotOver();

        _normalClaimAndBurn(_tokenId, _receiver);
    }

    /**
     * @notice Claims accumulated rewards for an NFT
     * @param _tokenId ID of the NFT to claim rewards for
     * @param _receiver Address to receive the rewards
     */
    function claim(uint256 _tokenId, address _receiver) public notAddress0(_receiver) notAmount0(_tokenId) {
        isApprovedOrOwner(_tokenId, msg.sender);

        _claim(_tokenId, _receiver);
    }

    /**
     * @notice Updates rewards across all pools if conditions are met
     * @dev Checks and distributes rewards for 8-day, 28-day, and 90-day pools
     */
    function updateRewardsIfNecessary() public {
        if (totalShares == 0) return;

        uint32 currentDay = _getCurrentDay();

        // Calculate how many periods have passed for each interval
        bool distributeDay8 = (currentDay / 8 > lastDistributedDay / 8);
        bool distributeDay28 = (currentDay / 28 > lastDistributedDay / 28);
        bool distributeDay90 = (currentDay / 90 > lastDistributedDay / 90);

        // Distribute for the 8-day pool if necessary
        if (distributeDay8) _updateRewards(POOLS.DAY8, toDistribute);

        // Distribute for the 28-day pool if necessary
        if (distributeDay28) _updateRewards(POOLS.DAY28, toDistribute);

        // Distribute for the 90-day pool if necessary
        if (distributeDay90) _updateRewards(POOLS.DAY90, toDistribute);

        // Update the last distributed day to the current day
        lastDistributedDay = currentDay;
    }

    /**
     * @notice Verifies if an address is authorized to handle a token
     * @param _tokenId The ID of the token to check
     * @param _spender The address to verify authorization for
     * @dev Wraps _checkAuthorized function from ERC721
     */
    function isApprovedOrOwner(uint256 _tokenId, address _spender) public view {
        _checkAuthorized(ownerOf(_tokenId), _spender, _tokenId);
    }

    /**
     * @notice Retrieves Ascendant token amount and tier percentage based on tier
     * @param _tier The tier level to get data for
     * @return tierValue The amount of Ascendant tokens required for the tier
     * @return multiplier The percentage multiplier for the tier (Ranging from 1.01e18 to 1.08e18)
     * @dev Reverts if tier is invalid
     */
    function getAscendantDataBasedOnTier(uint8 _tier) public pure returns (uint256 tierValue, uint64 multiplier) {
        require(_tier >= TIER_1 && _tier <= TIER_8, AscendantMinting__TierAmountMismatch());

        tierValue = ASCENDANT_TIER_1 << (_tier - 1); // Multiplies ASCENDANT_TIER_1 by 2^(_tier - 1)
        multiplier = WAD + (uint64(_tier) * 1e16); // WAD = 1e18, adds 0.01e18 per tier
    }

    //==========================//
    //==========EXTERNAL========//
    //==========================//

    /**
     * @notice Allows the contract owner to update the image URIs
     * @param _newTokenURIs New array of image URIs to set
     * @dev Must maintain the same structure: 8 tiers with 10 images each
     */
     function setTokenURIs(string[10][8] memory _newTokenURIs) external onlyOwner {
        tokenURIs = _newTokenURIs;
        emit BatchMetadataUpdate(0, type(uint256).max); // because it is required for OpenSea metadata update
    }

    /**
    * @notice Allows the contract owner to update a single token URI
    * @param _tier The tier level to update (1-8)
    * @param _index The index within the tier to update (0-9)
    * @param _newUri The new image URI to set
    * @dev Tier is 1-based but storage array is 0-based
    */
    function setSingleTokenURI(
        uint8 _tier, 
        uint256 _index, 
        string memory _newUri
    ) external onlyOwner {
        require(_tier >= 1 && _tier <= 8, "Invalid tier");
        require(_index < 10, "Invalid index");
    
        // tier - 1 because array is 0-based
        tokenURIs[_tier - 1][_index] = _newUri;

        emit BatchMetadataUpdate(0, type(uint256).max); // because it is required for OpenSea metadata update
    }


    /**
     * @notice Mints multiple NFTs of the same tier
     * @param _numOfNfts Number of NFTs to mint
     * @param _ascendantTier Tier level for all NFTs
     * @return tokenIds Array of minted token IDs
     * @return batchMintTotalShares Total shares assigned across all minted NFTs
     */
    function batchMint(uint8 _numOfNfts, uint8 _ascendantTier)
        public
        notAmount0(_numOfNfts)
        notAmount0(_ascendantTier)
        returns (uint256[] memory tokenIds, uint256 batchMintTotalShares)
    {
        tokenIds = new uint256[](_numOfNfts);

        for (uint8 i = 0; i < _numOfNfts; i++) {
            (uint256 _tokenId, uint256 shares) = mint(_ascendantTier);
            tokenIds[i] = _tokenId;
            batchMintTotalShares += shares;
        }

        return (tokenIds, batchMintTotalShares);
    }

    /**
     * @notice Mints a new NFT with the specified tier
     * @param _tier Tier level for the new NFT
     * @return _tokenId The ID of the newly minted NFT
     * @return shares The number of shares assigned to the NFT
     * @dev Transfers required Ascendant tokens from sender, creates NFT attributes, and updates total shares
     */
    function mint(uint8 _tier) public notAmount0(_tier) returns (uint256 _tokenId, uint256 shares) {
        (uint256 _ascendantAmount, uint64 _ascendantTierPercentage) = getAscendantDataBasedOnTier(_tier);

        updateRewardsIfNecessary();

        _tokenId = ++tokenId;

        shares = wmul(_ascendantAmount, _ascendantTierPercentage);

        userRecords[_tokenId] = UserRecord({
            startTime: Time.blockTs(),
            endTime: Time.blockTs() + MIN_DURATION,
            shares: shares,
            rewardDebt: rewardPerShare,
            lockedAscendant: _ascendantAmount
        });

        _generateNFTAttribute(_tokenId, _tier);

        totalShares += shares;

        ascendant.transferFrom(msg.sender, address(this), _ascendantAmount);

        emit Minted(msg.sender, _ascendantAmount, _tokenId, shares);

        _mint(msg.sender, _tokenId);

        emit MetadataUpdate(_tokenId); // because OpenSea listens for this type of events and once detected OpenSea refreshes the data
    }

    /**
     * @notice Calculates total claimable rewards for multiple NFTs
     * @param _ids Array of NFT IDs to check
     * @return toClaim Total amount of rewards claimable
     */
    function batchClaimableAmount(uint256[] calldata _ids) external view returns (uint256 toClaim) {
        uint32 currentDay = _getCurrentDay();

        uint256 m_rewardsPerShare = rewardPerShare;

        bool distributeDay8 = (currentDay / 8 > lastDistributedDay / 8);
        bool distributeDay28 = (currentDay / 28 > lastDistributedDay / 28);
        bool distributeDay90 = (currentDay / 90 > lastDistributedDay / 90);

        if (distributeDay8) m_rewardsPerShare += wdiv(toDistribute[POOLS.DAY8], totalShares);
        if (distributeDay28) m_rewardsPerShare += wdiv(toDistribute[POOLS.DAY28], totalShares);
        if (distributeDay90) m_rewardsPerShare += wdiv(toDistribute[POOLS.DAY90], totalShares);

        for (uint256 i; i < _ids.length; ++i) {
            uint256 _id = _ids[i];

            UserRecord memory _rec = userRecords[_id];
            toClaim += wmul(_rec.shares, m_rewardsPerShare - _rec.rewardDebt);
        }
    }

    /**
     * @notice Burns multiple NFTs
     * @param _ids Array of NFT IDs to burn
     * @param _receiver Address to receive the Ascendant tokens
     */
    function batchBurn(uint256[] calldata _ids, address _receiver) external {
        for (uint256 i; i < _ids.length; ++i) {
            burn(_ids[i], _receiver);
        }
    }

    /**
     * @notice Claims rewards for multiple NFTs
     * @param _ids Array of NFT IDs to claim rewards for
     * @param _receiver Address to receive the rewards
     */
    function batchClaim(uint256[] calldata _ids, address _receiver) external {
        for (uint256 i; i < _ids.length; ++i) {
            claim(_ids[i], _receiver);
        }
    }

    /**
     * @notice Distributes DragonX rewards to the reward pools
     * @param _amount Amount of DragonX tokens to distribute
     * @dev Transfers tokens from sender and updates reward pools
     */
    function distribute(uint256 _amount) external notAmount0(_amount) {
        dragonX.transferFrom(msg.sender, address(this), _amount);

        _distribute(_amount);
    }

    /**
     * @notice Combines two NFTs of the same tier to create a higher tier NFT
     * @param _firstTokenId First NFT to fuse
     * @param _secondTokenId Second NFT to fuse
     * @dev Both NFTs must be of the same tier and not expired
     */
    function fusion(uint256 _firstTokenId, uint256 _secondTokenId) external {
        if (_firstTokenId == _secondTokenId) revert AscendantMinting__FusionTokenIdsCannotBeTheSame();
        if (ownerOf(_firstTokenId) != msg.sender) revert AscendantMinting__InvalidNFTOwner();
        if (ownerOf(_secondTokenId) != msg.sender) revert AscendantMinting__InvalidNFTOwner();

        NftAttributes memory firstAttributes = nftAttributes[_firstTokenId];
        NftAttributes memory secondAttributes = nftAttributes[_secondTokenId];

        if (firstAttributes.tier != secondAttributes.tier) revert AscendantMinting__TierOfNFTsMustBeTheSame();
        if (firstAttributes.tier == TIER_8) revert AscendantMinting__MaxTierReached();

        _fusionClaimAndBurn(_firstTokenId, msg.sender);
        _fusionClaimAndBurn(_secondTokenId, msg.sender);

        uint8 incrementedTier = firstAttributes.tier + 1;

        (uint256 newTokenId, uint256 shares) = _fusionMint(incrementedTier);

        emit NFTFusion(_firstTokenId, _secondTokenId, newTokenId, shares, firstAttributes.tier, incrementedTier);
    }

    //==========================//
    //=========INTERNAL=========//
    //==========================//

    /**
     * @notice Internal function to process claims
     * @param _tokenId The ID of the NFT to claim rewards for
     * @param _receiver Address to receive the rewards
     * @dev Updates reward debt and transfers DragonX tokens
     */
    function _claim(uint256 _tokenId, address _receiver) internal {
        UserRecord storage _rec = userRecords[_tokenId];

        updateRewardsIfNecessary();

        uint256 amountToClaim = wmul(_rec.shares, rewardPerShare - _rec.rewardDebt);

        _rec.rewardDebt = rewardPerShare;

        dragonX.transfer(_receiver, amountToClaim);

        emit Claimed(_tokenId, amountToClaim, rewardPerShare, ownerOf(_tokenId));
    }

    /**
     * @notice Internal function to distribute rewards across pools
     * @param amount Amount of DragonX tokens to distribute
     * @dev Handles different distribution ratios based on current day
     */
    function _distribute(uint256 amount) internal {
        uint32 currentDay = _getCurrentDay();

        updateRewardsIfNecessary();

        if (currentDay == 1) {
            toDistribute[POOLS.DAY8] += amount;
        } else {
            toDistribute[POOLS.DAY8] += wmul(amount, DAY8POOL_DIST);
            toDistribute[POOLS.DAY28] += wmul(amount, DAY28POOL_DIST);
            toDistribute[POOLS.DAY90] += wmul(amount, DAY90POOL_DIST);
        }
    }

    /**
     * @notice Generates attributes for a newly minted NFT
     * @param _tokenId The ID of the NFT
     * @param _ascendantTier The tier level of the NFT
     * @dev Generates random number and sets rarity based on tier
     */
    function _generateNFTAttribute(uint256 _tokenId, uint8 _ascendantTier) internal {
        uint256 randomNumber = _generatePseudoRandom(_tokenId) % NUMBER_OF_NFT_IMAGES_PER_TIER;

        nftAttributes[_tokenId] =
            NftAttributes({
                tier: _ascendantTier,
                rarity: getRarity(randomNumber),
                rarityNumber: randomNumber
            });

        emit AscendantMinting__NFTAttributeGenerated(_tokenId, randomNumber, _ascendantTier);
    }

    /**
     * @notice Generates a pseudo-random number for NFT attributes
     * @param _tokenId The ID of the NFT to generate random number for
     * @return uint256 A pseudo-random number
     * @dev Uses block data and transaction data for randomness
     */
    function _generatePseudoRandom(uint256 _tokenId) internal view returns (uint256) {
        return uint256(
            keccak256(
                abi.encodePacked(
                    block.timestamp, block.prevrandao, blockhash(block.number - 1), tx.gasprice, msg.sender, _tokenId
                )
            )
        ) % NFT_ATTRIBUTE_RANDOM_NUMBER;
    }

    /**
     * @notice Updates rewards for a specific pool
     * @param pool The pool to update rewards for
     * @param toDist Storage mapping of distribution amounts
     * @dev Updates rewardPerShare and emits Distributed event
     */
    function _updateRewards(POOLS pool, mapping(POOLS => uint256) storage toDist) internal {
        if (toDist[pool] == 0) return;

        rewardPerShare += wdiv(toDist[pool], totalShares);

        emit Distributed(pool, toDist[pool]);

        toDistribute[pool] = 0;
    }

    /**
     * @notice Gets the current day number since contract start
     * @return currentDay The current day number (1-based)
     * @dev Returns 1 if contract hasn't started yet
     */
    function _getCurrentDay() internal view returns (uint32 currentDay) {
        if (startTimestamp > Time.blockTs()) {
            return 1;
        }
        return Time.dayGap(startTimestamp, Time.blockTs()) + 1;
    }

    /**
     * @notice Retrieves the NFT attributes for a given token ID
     * @param _tokenId The ID of the NFT
     * @return NftAttributes struct containing the NFT's attributes
     */
    function getNFTAttribute(uint256 _tokenId) external view returns (NftAttributes memory) {
        return nftAttributes[_tokenId];
    }

    //==========================//
    //=========PRIVATE==========//
    //==========================//

    /**
     * @notice Internal function to mint a new NFT during fusion
     * @param _tier The tier level of the new NFT
     * @return _tokenId The ID of the newly minted NFT
     * @return shares The number of shares assigned to the NFT
     * @dev Similar to public mint but skips token transfer as tokens are already in contract
     */
     function _fusionMint(uint8 _tier) private notAmount0(_tier) returns (uint256 _tokenId, uint256 shares) {
        (uint256 _ascendantAmount, uint64 _ascendantTierPercentage) = getAscendantDataBasedOnTier(_tier);

        updateRewardsIfNecessary();

        _tokenId = ++tokenId;

        shares = wmul(_ascendantAmount, _ascendantTierPercentage);

        userRecords[_tokenId] = UserRecord({
            startTime: Time.blockTs(),
            endTime: Time.blockTs() + MIN_DURATION,
            shares: shares,
            rewardDebt: rewardPerShare,
            lockedAscendant: _ascendantAmount
        });

        _generateNFTAttribute(_tokenId, _tier);

        totalShares += shares;

        // no need to transfer Ascendant tokens to the current contract
        // because this function is used only for fusion which means
        // that the ascendant is already in the contract

        emit Minted(msg.sender, _ascendantAmount, _tokenId, shares);

        _mint(msg.sender, _tokenId);

        emit MetadataUpdate(_tokenId); // because OpenSea listens for this type of events and once detected OpenSea refreshes the data
    }

    /**
     * @notice Burns an NFT and sends Ascendant tokens back to receiver after subtracting redeem tax
     * @param _tokenId The ID of the NFT to burn
     * @param _receiver Address to receive the Ascendant tokens and rewards
     * @dev Handles the standard burn process where Ascendant tokens are returned
     *      minus the redeem tax which is sent to AscendantPride
     */
    function _normalClaimAndBurn(uint256 _tokenId, address _receiver) private {
        _claimAndBurn(_tokenId, _receiver, false);
    }

    /**
     * @notice Burns an NFT during the fusion process without returning Ascendant tokens
     * @param _tokenId The ID of the NFT to burn
     * @param _receiver Address to receive only the DragonX rewards
     * @dev Used during fusion where Ascendant tokens remain in the contract
     *      to be used for minting the new higher tier NFT
     */
    function _fusionClaimAndBurn(uint256 _tokenId, address _receiver) private {
        _claimAndBurn(_tokenId, _receiver, true);
    }

    /**
     * @notice Internal function that handles the process of claiming rewards and burning an NFT
     * @param _tokenId The ID of the NFT to process
     * @param _receiver Address to receive tokens (DragonX rewards and optionally Ascendant tokens)
     * @param _isFusion Boolean indicating if this burn is part of a fusion operation
     * @dev This function:
     *      - Verifies ownership or approval
     *      - Claims any accumulated DragonX rewards
     *      - Cleans up NFT data (userRecords and nftAttributes)
     *      - Updates total shares
     *      - If not fusion: calculates and applies redeem tax, sends remaining Ascendant to receiver
     *      - If fusion: retains Ascendant tokens in contract
     *      - Burns the NFT
     *      - Emits either Burnt or FusionBurnt event depending on _isFusion
     */
    function _claimAndBurn(uint256 _tokenId, address _receiver, bool _isFusion)
        private
        notAddress0(_receiver)
        notAmount0(_tokenId)
    {
        UserRecord memory record = userRecords[_tokenId];

        isApprovedOrOwner(_tokenId, msg.sender);

        _claim(_tokenId, _receiver);

        uint256 _shares = record.shares;

        delete userRecords[_tokenId];

        delete nftAttributes[_tokenId];

        totalShares -= record.shares;

        if (!_isFusion) {
            uint256 _ascendantRedeemTax = wmul(record.lockedAscendant, ASCENDANT_REDEEM_TAX);

            uint256 _ascendantToReturn = record.lockedAscendant - _ascendantRedeemTax;

            ascendant.transfer(ascendantPride, _ascendantRedeemTax);

            ascendant.transfer(_receiver, _ascendantToReturn);

            emit Burnt(_shares, _ascendantToReturn, _tokenId, _receiver);
        } else {
            emit FusionBurnt(_shares, _tokenId, _receiver);
        }

        _burn(_tokenId);
    }

    /**
    * @notice Determines rarity based on a pseudo-random number 0-9
    * @param number The pseudo-random number input (must be 0-9)
    * @return Rarity enum value (LEGENDARY for 0, COMMON for 1-7, RARE for 8-9)
    * @dev Used for weighted rarity distribution:
    *      - 10% chance for LEGENDARY (number = 0)
    *      - 70% chance for COMMON (numbers 1-7) 
    *      - 20% chance for RARE (numbers 8-9)
    */    
    function getRarity(uint256 number) private pure returns (Rarity) {
        if (number == 0) return Rarity.LEGENDARY;    // 10% chance
        if (number <= 7) return Rarity.COMMON;       // 70% chance
        return Rarity.RARE;                          // 20% chance
    }

}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

import "@const/Constants.sol";
import {wmul} from "@utils/Math.sol";
import {IAscendant} from "@interfaces/IAscendant.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/**
 * @title AscendantPride Contract
 * @author Decentra
 * @notice Contract that manages the accumulation and distribution of Ascendant tokens for the auction system
 */
contract AscendantPride {
    using SafeERC20 for IAscendant;

    /* === IMMUTABLES === */

    /**
     * @notice Interface to the Ascendant token contract for token transfers and balance checks
     */
    IAscendant immutable ascendant;

    /**
     * @notice Address of the auction contract authorized to call emitForAuction
     * @dev Immutable reference set in constructor, used for access control validation
     */
    address immutable auction;

    /* === ERRORS === */
    error AscendantPride__OnlyAuction();

    /* === CONSTRUCTOR === */

    /**
     * @notice Initializes the AscendantPride contract
     * @param _auction Address of the auction contract that will receive distributed tokens
     * @param _ascendant Address of the Ascendant token contract
     */
    constructor(address _auction, address _ascendant) {
        auction = _auction;
        ascendant = IAscendant(_ascendant);
    }

    //==========================//
    //=========MODIFIERS========//
    //==========================//

    /**
     * @dev Modifier to restrict function access to auction contract only
     */
    modifier onlyAuction() {
        _onlyAuction();
        _;
    }

    //==========================//
    //=========EXTERNAL=========//
    //==========================//

    /**
     * @notice Distributes tokens to the auction contract
     * @return emitted Amount of tokens transferred to the auction
     */
    function emitForAuction() external onlyAuction returns (uint256 emitted) {
        uint256 balanceOf = ascendant.balanceOf(address(this));

        emitted = wmul(balanceOf, DISTRIBUTION_FROM_THE_ASCENDANT);

        ascendant.safeTransfer(msg.sender, emitted);
    }

    //==========================//
    //=========INTERNAL=========//
    //==========================//

    /**
     * @dev Internal function to validate caller is auction contract
     */
    function _onlyAuction() internal view {
        if (msg.sender != auction) revert AscendantPride__OnlyAuction();
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

address constant DEAD_ADDR = 0x000000000000000000000000000000000000dEaD;
address constant LIQUIDITY_BONDING = 0xC3F351f58b4CAF38fd76623c1bED015E59107506;
address constant GENESIS_WALLET_1 = 0x7671fd00048aB79C7D2aeCd035a3712C8eD52Aa5;
address constant GENESIS_WALLET_2 = 0x0a71b0F495948C4b3C3b9D0ADa939681BfBEEf30;
address constant TITANX_WETH_POOL = 0xc45A81BC23A64eA556ab4CdF08A86B61cdcEEA8b;

// Percentages in basis points
uint64 constant GENESIS = 0.08e18; // 8%
uint64 constant INCENTIVE_FEE = 0.015e18; //1.5%
uint64 constant HALF = 0.5e18; // 50%
uint64 constant THIRTY_PERCENT = 0.3e18; // 30%
uint64 constant SEVENTY_PERCENT = 0.7e18; // 70%
uint64 constant DRAGONX_TO_ASCENDANT_RATIO = 0.8e18; // 80%
uint64 constant DRAGONX_TO_REWARD_POOL_RATIO = 0.2e18; // 20%
uint64 constant TITANX_TO_TINC_RATIO = 0.2e18; // 20%
uint64 constant TITANX_TO_DRAGONX_RATIO = 0.72e18; // 72%
uint64 constant ASCENDANT_REDEEM_TAX = 0.06e18; // 6%
uint64 constant ASCENDANT_NFT_SALE_FEE = 0.01e18; // 1%
uint64 constant TITAN_X_LP_TAX = 0.01e18; // 1%

uint8 constant DAY_10 = 10;

uint8 constant TIER_1 = 1;
uint8 constant TIER_2 = 2;
uint8 constant TIER_3 = 3;
uint8 constant TIER_4 = 4;
uint8 constant TIER_5 = 5;
uint8 constant TIER_6 = 6;
uint8 constant TIER_7 = 7;
uint8 constant TIER_8 = 8;
uint8 constant NUMBER_OF_NFT_IMAGES_PER_TIER = 10;

uint64 constant TIER_1_PERCENTAGE = 1.01e18; // 1%
uint64 constant TIER_2_PERCENTAGE = 1.02e18; // 2%
uint64 constant TIER_3_PERCENTAGE = 1.03e18; // 3%
uint64 constant TIER_4_PERCENTAGE = 1.04e18; // 4%
uint64 constant TIER_5_PERCENTAGE = 1.05e18; // 5%
uint64 constant TIER_6_PERCENTAGE = 1.06e18; // 6%
uint64 constant TIER_7_PERCENTAGE = 1.07e18; // 7%
uint64 constant TIER_8_PERCENTAGE = 1.08e18; // 8%

uint32 constant MIN_DURATION = 8 days;
uint32 constant THREE_MONTHS_DURATION = 90 days;

uint256 constant INITIAL_TO_ASCENDANT_PRIDE = 288_000_000e18;

uint256 constant ASCENDANT_TIER_1 = 7_812.5e18; // 7,812.5 Ascendant with 18 decimals
uint256 constant ASCENDANT_TIER_2 = 15_625e18; // 15,625 Ascendant with 18 decimals
uint256 constant ASCENDANT_TIER_3 = 31_250e18; // 31,250 Ascendant with 18 decimals
uint256 constant ASCENDANT_TIER_4 = 62_500e18; // 62,500 Ascendant with 18 decimals
uint256 constant ASCENDANT_TIER_5 = 125_000e18; // 125,000 Ascendant with 18 decimals
uint256 constant ASCENDANT_TIER_6 = 250_000e18; // 250,000 Ascendant with 18 decimals
uint256 constant ASCENDANT_TIER_7 = 500_000e18; // 500,000 Ascendant with 18 decimals
uint256 constant ASCENDANT_TIER_8 = 1_000_000e18; // 1,000,000 Ascendant with 18 decimals

// Reward pools distribution
uint64 constant DAY8POOL_DIST = 0.5e18; // 50%
uint64 constant DAY28POOL_DIST = 0.25e18; // 25%
uint64 constant DAY90POOL_DIST = 0.25e18; // 25%

uint64 constant DISTRIBUTION_FROM_THE_ASCENDANT = 0.08e18; // 8%
uint64 constant WAD = 1e18;
uint32 constant NFT_ATTRIBUTE_RANDOM_NUMBER = 144;

/// @dev 288 * 5 = 24 hours
uint16 constant INTERVAL_TIME = 5 minutes;
uint16 constant INTERVALS_PER_DAY = uint16(24 hours / INTERVAL_TIME);

uint24 constant POOL_FEE = 10_000; // 1%
int16 constant TICK_SPACING = 200; // Uniswap's tick spacing for 1% pools is 200

///@dev The initial titanX amount needed to create liquidity pool
uint256 constant INITIAL_TITAN_X_FOR_LIQ = 14_000_000_000e18;
uint256 constant AUCTION_EMIT = 100_000_000e18;

///@dev The intial Ascendant that pairs with the initial TitanX
uint256 constant INITIAL_ASCENDANT_FOR_LP = 5_000_000e18;

// 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/introspection/ERC165.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.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.0.0) (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys a `value` amount of tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 value) public virtual {
        _burn(_msgSender(), value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, deducting from
     * the caller's allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `value`.
     */
    function burnFrom(address account, uint256 value) public virtual {
        _spendAllowance(account, _msgSender(), value);
        _burn(account, value);
    }
}

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

pragma solidity ^0.8.20;

import {IERC721} from "./IERC721.sol";
import {IERC721Metadata} from "./extensions/IERC721Metadata.sol";
import {ERC721Utils} from "./utils/ERC721Utils.sol";
import {Context} from "../../utils/Context.sol";
import {Strings} from "../../utils/Strings.sol";
import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol";
import {IERC721Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC-721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    mapping(uint256 tokenId => address) private _owners;

    mapping(address owner => uint256) private _balances;

    mapping(uint256 tokenId => address) private _tokenApprovals;

    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual returns (uint256) {
        if (owner == address(0)) {
            revert ERC721InvalidOwner(address(0));
        }
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual returns (address) {
        return _requireOwned(tokenId);
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
        _requireOwned(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual {
        _approve(to, tokenId, _msgSender());
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual returns (address) {
        _requireOwned(tokenId);

        return _getApproved(tokenId);
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        address previousOwner = _update(to, tokenId, _msgSender());
        if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
        transferFrom(from, to, tokenId);
        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     *
     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
     * core ERC-721 logic MUST be matched with the use of {_increaseBalance} to keep balances
     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
     */
    function _getApproved(uint256 tokenId) internal view virtual returns (address) {
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
     * particular (ignoring whether it is owned by `owner`).
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
        return
            spender != address(0) &&
            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
    }

    /**
     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
     * Reverts if:
     * - `spender` does not have approval from `owner` for `tokenId`.
     * - `spender` does not have approval to manage all of `owner`'s assets.
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
        if (!_isAuthorized(owner, spender, tokenId)) {
            if (owner == address(0)) {
                revert ERC721NonexistentToken(tokenId);
            } else {
                revert ERC721InsufficientApproval(spender, tokenId);
            }
        }
    }

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
     *
     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the
     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
     * remain consistent with one another.
     */
    function _increaseBalance(address account, uint128 value) internal virtual {
        unchecked {
            _balances[account] += value;
        }
    }

    /**
     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that
     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).
     *
     * Emits a {Transfer} event.
     *
     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
        address from = _ownerOf(tokenId);

        // Perform (optional) operator check
        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        // Execute the update
        if (from != address(0)) {
            // Clear approval. No need to re-authorize or emit the Approval event
            _approve(address(0), tokenId, address(0), false);

            unchecked {
                _balances[from] -= 1;
            }
        }

        if (to != address(0)) {
            unchecked {
                _balances[to] += 1;
            }
        }

        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        return from;
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner != address(0)) {
            revert ERC721InvalidSender(address(0));
        }
    }

    /**
     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
        _mint(to, tokenId);
        ERC721Utils.checkOnERC721Received(_msgSender(), address(0), to, tokenId, data);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal {
        address previousOwner = _update(address(0), tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        } else if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients
     * are aware of the ERC-721 standard to prevent tokens from being forever locked.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is like {safeTransferFrom} in the sense that it invokes
     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `tokenId` token must exist and be owned by `from`.
     * - `to` cannot be the zero address.
     * - `from` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId) internal {
        _safeTransfer(from, to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
     * either the owner of the token, or approved to operate on all tokens held by this owner.
     *
     * Emits an {Approval} event.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address to, uint256 tokenId, address auth) internal {
        _approve(to, tokenId, auth, true);
    }

    /**
     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
     * emitted in the context of transfers.
     */
    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
        // Avoid reading the owner unless necessary
        if (emitEvent || auth != address(0)) {
            address owner = _requireOwned(tokenId);

            // We do not use _isAuthorized because single-token approvals should not be able to call approve
            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
                revert ERC721InvalidApprover(auth);
            }

            if (emitEvent) {
                emit Approval(owner, to, tokenId);
            }
        }

        _tokenApprovals[tokenId] = to;
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Requirements:
     * - operator can't be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        if (operator == address(0)) {
            revert ERC721InvalidOperator(operator);
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
     * Returns the owner.
     *
     * Overrides to ownership logic should be done to {_ownerOf}.
     */
    function _requireOwned(uint256 tokenId) internal view returns (address) {
        address owner = _ownerOf(tokenId);
        if (owner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
        return owner;
    }
}

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

pragma solidity ^0.8.20;

import {ERC721} from "../ERC721.sol";
import {Strings} from "../../../utils/Strings.sol";
import {IERC4906} from "../../../interfaces/IERC4906.sol";
import {IERC165} from "../../../interfaces/IERC165.sol";

/**
 * @dev ERC-721 token with storage based token URI management.
 */
abstract contract ERC721URIStorage is IERC4906, ERC721 {
    using Strings for uint256;

    // Interface ID as defined in ERC-4906. This does not correspond to a traditional interface ID as ERC-4906 only
    // defines events and does not include any external function.
    bytes4 private constant ERC4906_INTERFACE_ID = bytes4(0x49064906);

    // Optional mapping for token URIs
    mapping(uint256 tokenId => string) private _tokenURIs;

    /**
     * @dev See {IERC165-supportsInterface}
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, IERC165) returns (bool) {
        return interfaceId == ERC4906_INTERFACE_ID || super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireOwned(tokenId);

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = _baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via string.concat).
        if (bytes(_tokenURI).length > 0) {
            return string.concat(base, _tokenURI);
        }

        return super.tokenURI(tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Emits {MetadataUpdate}.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        _tokenURIs[tokenId] = _tokenURI;
        emit MetadataUpdate(tokenId);
    }
}

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

pragma solidity ^0.8.20;

import {IERC721Receiver} from "../IERC721Receiver.sol";
import {IERC721Errors} from "../../../interfaces/draft-IERC6093.sol";

/**
 * @dev Library that provide common ERC-721 utility functions.
 *
 * See https://eips.ethereum.org/EIPS/eip-721[ERC-721].
 *
 * _Available since v5.1._
 */
library ERC721Utils {
    /**
     * @dev Performs an acceptance check for the provided `operator` by calling {IERC721-onERC721Received}
     * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`).
     *
     * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA).
     * Otherwise, the recipient must implement {IERC721Receiver-onERC721Received} and return the acceptance magic value to accept
     * the transfer.
     */
    function checkOnERC721Received(
        address operator,
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal {
        if (to.code.length > 0) {
            try IERC721Receiver(to).onERC721Received(operator, from, tokenId, data) returns (bytes4 retval) {
                if (retval != IERC721Receiver.onERC721Received.selector) {
                    // Token rejected
                    revert IERC721Errors.ERC721InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-IERC721Receiver implementer
                    revert IERC721Errors.ERC721InvalidReceiver(to);
                } else {
                    assembly ("memory-safe") {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

contract Errors {
    /// @notice Error thrown when an address is the zero address.
    error Address0();
    /// @notice Error thrown when the caller is not an EOA.
    error OnlyEOA();

    /// @notice Error thrown when an amount is zero.
    error Amount0();

    /// @notice Error thrown when an operation is attempted after the specified deadline.
    error Expired();

    /// @notice Error thrown when one value is greater than another.
    /// @param a The first value that is greater than the second value.
    /// @param b The second value which is smaller or equal to the first value.
    error GreaterThan(uint256 a, uint256 b);

    /**
     * @notice Modifier to prevent operations with a zero amount.
     * @dev Throws an `Amount0` error if the provided amount is zero.
     * @param a The amount to be checked.
     */
    modifier notAmount0(uint256 a) {
        require(a != 0, Amount0());
        _;
    }

    /**
     * @notice Modifier to ensure a function is called before a specified deadline.
     * @dev Throws an `Expired` error if the current block timestamp exceeds the provided deadline.
     * @param _deadline The deadline timestamp by which the function must be called.
     */
    modifier notExpired(uint32 _deadline) {
        require(block.timestamp <= _deadline, Expired());
        _;
    }

    /**
     * @notice Modifier to prevent operations with the zero address.
     * @dev Throws an `Address0` error if the provided address is the zero address.
     * @param a The address to be checked.
     */
    modifier notAddress0(address a) {
        require(a != address(0), Address0());
        _;
    }

    /**
     * @notice Modifier to ensure the second value is not greater than the first.
     * @dev Throws a `GreaterThan` error if `b` is smaller than `a`.
     * @param a The first value to be compared.
     * @param b The second value to be compared.
     */
    modifier notGt(uint256 a, uint256 b) {
        require(b >= a, GreaterThan(a, b));
        _;
    }

    /**
     * @notice Modifier to prevent operations when the caller is not an EOA.
     * @dev Throws an `OnlyEOA` error if the caller is not an EOA.
     */
    modifier onlyEOA() {
        require(msg.sender.code.length == 0 && tx.origin == msg.sender, OnlyEOA());
        _;
    }

    function _onlyEOA() internal view {
        require(msg.sender.code.length == 0 && tx.origin == msg.sender, OnlyEOA());
    }

    function _notGt(uint256 a, uint256 b) internal pure {
        require(b >= a, GreaterThan(a, b));
    }

    function _notAddress0(address a) internal pure {
        require(a != address(0), Address0());
    }

    function _notExpired(uint32 _deadline) internal view {
        require(block.timestamp <= _deadline, Expired());
    }

    function _notAmount0(uint256 a) internal pure {
        require(a != 0, Amount0());
    }
}

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

/// @title Contains 512-bit math functions
/// @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision
/// @dev Handles "phantom overflow" i.e., allows multiplication and division where an intermediate value overflows 256 bits
library FullMath {
    /// @notice Calculates floor(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
    /// @param a The multiplicand
    /// @param b The multiplier
    /// @param denominator The divisor
    /// @return result The 256-bit result
    /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv
    function mulDiv(
        uint256 a,
        uint256 b,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = a * b
            // Compute the product mod 2**256 and mod 2**256 - 1
            // then use the Chinese Remainder Theorem to reconstruct
            // the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2**256 + prod0
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(a, b, not(0))
                prod0 := mul(a, b)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division
            if (prod1 == 0) {
                require(denominator > 0);
                assembly {
                    result := div(prod0, denominator)
                }
                return result;
            }

            // Make sure the result is less than 2**256.
            // Also prevents denominator == 0
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0]
            // Compute remainder using mulmod
            uint256 remainder;
            assembly {
                remainder := mulmod(a, b, denominator)
            }
            // Subtract 256 bit number from 512 bit number
            assembly {
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator
            // Compute largest power of two divisor of denominator.
            // Always >= 1.
            uint256 twos = (0 - denominator) & denominator;
            // Divide denominator by power of two
            assembly {
                denominator := div(denominator, twos)
            }

            // Divide [prod1 prod0] by the factors of two
            assembly {
                prod0 := div(prod0, twos)
            }
            // Shift in bits from prod1 into prod0. For this we need
            // to flip `twos` such that it is 2**256 / twos.
            // If twos is zero, then it becomes one
            assembly {
                twos := add(div(sub(0, twos), twos), 1)
            }
            prod0 |= prod1 * twos;

            // Invert denominator mod 2**256
            // Now that denominator is an odd number, it has an inverse
            // modulo 2**256 such that denominator * inv = 1 mod 2**256.
            // Compute the inverse by starting with a seed that is correct
            // correct for four bits. That is, denominator * inv = 1 mod 2**4
            uint256 inv = (3 * denominator) ^ 2;
            // Now use Newton-Raphson iteration to improve the precision.
            // Thanks to Hensel's lifting lemma, this also works in modular
            // arithmetic, doubling the correct bits in each step.
            inv *= 2 - denominator * inv; // inverse mod 2**8
            inv *= 2 - denominator * inv; // inverse mod 2**16
            inv *= 2 - denominator * inv; // inverse mod 2**32
            inv *= 2 - denominator * inv; // inverse mod 2**64
            inv *= 2 - denominator * inv; // inverse mod 2**128
            inv *= 2 - denominator * inv; // inverse mod 2**256

            // Because the division is now exact we can divide by multiplying
            // with the modular inverse of denominator. This will give us the
            // correct result modulo 2**256. Since the precoditions guarantee
            // that the outcome is less than 2**256, this is the final result.
            // We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inv;
            return result;
        }
    }

    /// @notice Calculates ceil(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
    /// @param a The multiplicand
    /// @param b The multiplier
    /// @param denominator The divisor
    /// @return result The 256-bit result
    function mulDivRoundingUp(
        uint256 a,
        uint256 b,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            result = mulDiv(a, b, denominator);
            if (mulmod(a, b, denominator) > 0) {
                require(result < type(uint256).max);
                result++;
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";

import {AscendantAuction} from "@core/AscendantAuction.sol";
import {Ascendant} from "@core/Ascendant.sol";

interface IAscendantBuyAndBurn {
    function distributeTitanXForBurning(uint256 _amount) external;
}

interface IAscendantNFTMinting {
    function claim(uint256 _tokenId, address _receiver) external;
}

interface IAscendant is IERC20 {
    /* == ERRORS == */
    error Ascendant__OnlyAuction();

    /* == VIEW FUNCTIONS == */
    function auction() external view returns (AscendantAuction);
    function buyAndBurn() external view returns (IAscendantBuyAndBurn);
    function pool() external view returns (address);

    /* == EXTERNAL FUNCTIONS == */
    function burn(uint256 amount) external;

    function emitForAuction() external returns (uint256 emitted);

    function emitForLp() external returns (uint256 emitted);
}

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

pragma solidity ^0.8.20;

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

/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)

pragma solidity ^0.8.20;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)

pragma solidity ^0.8.20;

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

// 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) (interfaces/IERC4906.sol)

pragma solidity ^0.8.20;

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

/// @title ERC-721 Metadata Update Extension
interface IERC4906 is IERC165, IERC721 {
    /// @dev This event emits when the metadata of a token is changed.
    /// So that the third-party platforms such as NFT market could
    /// timely update the images and related attributes of the NFT.
    event MetadataUpdate(uint256 _tokenId);

    /// @dev This event emits when the metadata of a range of tokens is changed.
    /// So that the third-party platforms such as NFT market could
    /// timely update the images and related attributes of the NFTs.
    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
}

// 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.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.0.0) (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.20;

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

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;

import '@openzeppelin/contracts/token/ERC721/IERC721.sol';

/// @title ERC721 with permit
/// @notice Extension to ERC721 that includes a permit function for signature based approvals
interface IERC721Permit is IERC721 {
    /// @notice The permit typehash used in the permit signature
    /// @return The typehash for the permit
    function PERMIT_TYPEHASH() external pure returns (bytes32);

    /// @notice The domain separator used in the permit signature
    /// @return The domain seperator used in encoding of permit signature
    function DOMAIN_SEPARATOR() external view returns (bytes32);

    /// @notice Approve of a specific token ID for spending by spender via signature
    /// @param spender The account that is being approved
    /// @param tokenId The ID of the token that is being approved for spending
    /// @param deadline The deadline timestamp by which the call must be mined for the approve to work
    /// @param v Must produce valid secp256k1 signature from the holder along with `r` and `s`
    /// @param r Must produce valid secp256k1 signature from the holder along with `v` and `s`
    /// @param s Must produce valid secp256k1 signature from the holder along with `r` and `v`
    function permit(
        address spender,
        uint256 tokenId,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external payable;
}

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

pragma solidity ^0.8.20;

/**
 * @title ERC-721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC-721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be
     * reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

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

import './IPoolInitializer.sol';
import './IERC721Permit.sol';
import './IPeripheryPayments.sol';
import './IPeripheryImmutableState.sol';
import '../libraries/PoolAddress.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
    IPoolInitializer,
    IPeripheryPayments,
    IPeripheryImmutableState,
    IERC721Metadata,
    IERC721Enumerable,
    IERC721Permit
{
    /// @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 nonce The nonce for permits
    /// @return operator The address that is approved for spending
    /// @return token0 The address of the token0 for a specific pool
    /// @return token1 The address of the token1 for a specific pool
    /// @return fee 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 (
            uint96 nonce,
            address operator,
            address token0,
            address token1,
            uint24 fee,
            int24 tickLower,
            int24 tickUpper,
            uint128 liquidity,
            uint256 feeGrowthInside0LastX128,
            uint256 feeGrowthInside1LastX128,
            uint128 tokensOwed0,
            uint128 tokensOwed1
        );

    struct MintParams {
        address token0;
        address token1;
        uint24 fee;
        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.5.0;

/// @title Immutable state
/// @notice Functions that return immutable state of the router
interface IPeripheryImmutableState {
    /// @return Returns the address of the Uniswap V3 factory
    function factory() external view returns (address);

    /// @return Returns the address of WETH9
    function WETH9() external view returns (address);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;

/// @title Periphery Payments
/// @notice Functions to ease deposits and withdrawals of ETH
interface IPeripheryPayments {
    /// @notice Unwraps the contract's WETH9 balance and sends it to recipient as ETH.
    /// @dev The amountMinimum parameter prevents malicious contracts from stealing WETH9 from users.
    /// @param amountMinimum The minimum amount of WETH9 to unwrap
    /// @param recipient The address receiving ETH
    function unwrapWETH9(uint256 amountMinimum, address recipient) external payable;

    /// @notice Refunds any ETH balance held by this contract to the `msg.sender`
    /// @dev Useful for bundling with mint or increase liquidity that uses ether, or exact output swaps
    /// that use ether for the input amount
    function refundETH() external payable;

    /// @notice Transfers the full amount of a token held by this contract to recipient
    /// @dev The amountMinimum parameter prevents malicious contracts from stealing the token from users
    /// @param token The contract address of the token which will be transferred to `recipient`
    /// @param amountMinimum The minimum amount of token required for a transfer
    /// @param recipient The destination address of the token
    function sweepToken(
        address token,
        uint256 amountMinimum,
        address recipient
    ) external payable;
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

/// @title Creates and initializes V3 Pools
/// @notice Provides a method for creating and initializing a pool, if necessary, for bundling with other methods that
/// require the pool to exist.
interface IPoolInitializer {
    /// @notice Creates a new pool if it does not exist, then initializes if not initialized
    /// @dev This method can be bundled with others via IMulticall for the first action (e.g. mint) performed against a pool
    /// @param token0 The contract address of token0 of the pool
    /// @param token1 The contract address of token1 of the pool
    /// @param fee The fee amount of the v3 pool for the specified token pair
    /// @param sqrtPriceX96 The initial square root price of the pool as a Q64.96 value
    /// @return pool Returns the pool address based on the pair of tokens and fee, will return the newly created pool address if necessary
    function createAndInitializePoolIfNecessary(
        address token0,
        address token1,
        uint24 fee,
        uint160 sqrtPriceX96
    ) external payable returns (address pool);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

/// @title Quoter Interface
/// @notice Supports quoting the calculated amounts from exact input or exact output swaps
/// @dev These functions are not marked view because they rely on calling non-view functions and reverting
/// to compute the result. They are also not gas efficient and should not be called on-chain.
interface IQuoter {
    /// @notice Returns the amount out received for a given exact input swap without executing the swap
    /// @param path The path of the swap, i.e. each token pair and the pool fee
    /// @param amountIn The amount of the first token to swap
    /// @return amountOut The amount of the last token that would be received
    function quoteExactInput(bytes memory path, uint256 amountIn) external returns (uint256 amountOut);

    /// @notice Returns the amount out received for a given exact input but for a swap of a single pool
    /// @param tokenIn The token being swapped in
    /// @param tokenOut The token being swapped out
    /// @param fee The fee of the token pool to consider for the pair
    /// @param amountIn The desired input amount
    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
    /// @return amountOut The amount of `tokenOut` that would be received
    function quoteExactInputSingle(
        address tokenIn,
        address tokenOut,
        uint24 fee,
        uint256 amountIn,
        uint160 sqrtPriceLimitX96
    ) external returns (uint256 amountOut);

    /// @notice Returns the amount in required for a given exact output swap without executing the swap
    /// @param path The path of the swap, i.e. each token pair and the pool fee. Path must be provided in reverse order
    /// @param amountOut The amount of the last token to receive
    /// @return amountIn The amount of first token required to be paid
    function quoteExactOutput(bytes memory path, uint256 amountOut) external returns (uint256 amountIn);

    /// @notice Returns the amount in required to receive the given exact output amount but for a swap of a single pool
    /// @param tokenIn The token being swapped in
    /// @param tokenOut The token being swapped out
    /// @param fee The fee of the token pool to consider for the pair
    /// @param amountOut The desired output amount
    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
    /// @return amountIn The amount required as the input for the swap in order to receive `amountOut`
    function quoteExactOutputSingle(
        address tokenIn,
        address tokenOut,
        uint24 fee,
        uint256 amountOut,
        uint160 sqrtPriceLimitX96
    ) external returns (uint256 amountIn);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

import '@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3SwapCallback.sol';

/// @title Router token swapping functionality
/// @notice Functions for swapping tokens via Uniswap V3
interface ISwapRouter is IUniswapV3SwapCallback {
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Swaps `amountIn` of one token for as much as possible of another token
    /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
    /// @return amountOut The amount of the received token
    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);

    struct ExactInputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
    }

    /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
    /// @return amountOut The amount of the received token
    function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);

    struct ExactOutputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Swaps as little as possible of one token for `amountOut` of another token
    /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
    /// @return amountIn The amount of the input token
    function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);

    struct ExactOutputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
    }

    /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
    /// @return amountIn The amount of the input token
    function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

import {IUniswapV3PoolImmutables} from './pool/IUniswapV3PoolImmutables.sol';
import {IUniswapV3PoolState} from './pool/IUniswapV3PoolState.sol';
import {IUniswapV3PoolDerivedState} from './pool/IUniswapV3PoolDerivedState.sol';
import {IUniswapV3PoolActions} from './pool/IUniswapV3PoolActions.sol';
import {IUniswapV3PoolOwnerActions} from './pool/IUniswapV3PoolOwnerActions.sol';
import {IUniswapV3PoolErrors} from './pool/IUniswapV3PoolErrors.sol';
import {IUniswapV3PoolEvents} from './pool/IUniswapV3PoolEvents.sol';

/// @title The interface for a Uniswap V3 Pool
/// @notice A Uniswap pool facilitates swapping and automated market making between any two assets that strictly conform
/// to the ERC20 specification
/// @dev The pool interface is broken up into many smaller pieces
interface IUniswapV3Pool is
    IUniswapV3PoolImmutables,
    IUniswapV3PoolState,
    IUniswapV3PoolDerivedState,
    IUniswapV3PoolActions,
    IUniswapV3PoolOwnerActions,
    IUniswapV3PoolErrors,
    IUniswapV3PoolEvents
{

}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Permissionless pool actions
/// @notice Contains pool methods that can be called by anyone
interface IUniswapV3PoolActions {
    /// @notice Sets the initial price for the pool
    /// @dev Price is represented as a sqrt(amountToken1/amountToken0) Q64.96 value
    /// @param sqrtPriceX96 the initial sqrt price of the pool as a Q64.96
    function initialize(uint160 sqrtPriceX96) external;

    /// @notice Adds liquidity for the given recipient/tickLower/tickUpper position
    /// @dev The caller of this method receives a callback in the form of IUniswapV3MintCallback#uniswapV3MintCallback
    /// in which they must pay any token0 or token1 owed for the liquidity. The amount of token0/token1 due depends
    /// on tickLower, tickUpper, the amount of liquidity, and the current price.
    /// @param recipient The address for which the liquidity will be created
    /// @param tickLower The lower tick of the position in which to add liquidity
    /// @param tickUpper The upper tick of the position in which to add liquidity
    /// @param amount The amount of liquidity to mint
    /// @param data Any data that should be passed through to the callback
    /// @return amount0 The amount of token0 that was paid to mint the given amount of liquidity. Matches the value in the callback
    /// @return amount1 The amount of token1 that was paid to mint the given amount of liquidity. Matches the value in the callback
    function mint(
        address recipient,
        int24 tickLower,
        int24 tickUpper,
        uint128 amount,
        bytes calldata data
    ) external returns (uint256 amount0, uint256 amount1);

    /// @notice Collects tokens owed to a position
    /// @dev Does not recompute fees earned, which must be done either via mint or burn of any amount of liquidity.
    /// Collect must be called by the position owner. To withdraw only token0 or only token1, amount0Requested or
    /// amount1Requested may be set to zero. To withdraw all tokens owed, caller may pass any value greater than the
    /// actual tokens owed, e.g. type(uint128).max. Tokens owed may be from accumulated swap fees or burned liquidity.
    /// @param recipient The address which should receive the fees collected
    /// @param tickLower The lower tick of the position for which to collect fees
    /// @param tickUpper The upper tick of the position for which to collect fees
    /// @param amount0Requested How much token0 should be withdrawn from the fees owed
    /// @param amount1Requested How much token1 should be withdrawn from the fees owed
    /// @return amount0 The amount of fees collected in token0
    /// @return amount1 The amount of fees collected in token1
    function collect(
        address recipient,
        int24 tickLower,
        int24 tickUpper,
        uint128 amount0Requested,
        uint128 amount1Requested
    ) external returns (uint128 amount0, uint128 amount1);

    /// @notice Burn liquidity from the sender and account tokens owed for the liquidity to the position
    /// @dev Can be used to trigger a recalculation of fees owed to a position by calling with an amount of 0
    /// @dev Fees must be collected separately via a call to #collect
    /// @param tickLower The lower tick of the position for which to burn liquidity
    /// @param tickUpper The upper tick of the position for which to burn liquidity
    /// @param amount How much liquidity to burn
    /// @return amount0 The amount of token0 sent to the recipient
    /// @return amount1 The amount of token1 sent to the recipient
    function burn(
        int24 tickLower,
        int24 tickUpper,
        uint128 amount
    ) external returns (uint256 amount0, uint256 amount1);

    /// @notice Swap token0 for token1, or token1 for token0
    /// @dev The caller of this method receives a callback in the form of IUniswapV3SwapCallback#uniswapV3SwapCallback
    /// @param recipient The address to receive the output of the swap
    /// @param zeroForOne The direction of the swap, true for token0 to token1, false for token1 to token0
    /// @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
    /// @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this
    /// value after the swap. If one for zero, the price cannot be greater than this value after the swap
    /// @param data Any data to be passed through to the callback
    /// @return amount0 The delta of the balance of token0 of the pool, exact when negative, minimum when positive
    /// @return amount1 The delta of the balance of token1 of the pool, exact when negative, minimum when positive
    function swap(
        address recipient,
        bool zeroForOne,
        int256 amountSpecified,
        uint160 sqrtPriceLimitX96,
        bytes calldata data
    ) external returns (int256 amount0, int256 amount1);

    /// @notice Receive token0 and/or token1 and pay it back, plus a fee, in the callback
    /// @dev The caller of this method receives a callback in the form of IUniswapV3FlashCallback#uniswapV3FlashCallback
    /// @dev Can be used to donate underlying tokens pro-rata to currently in-range liquidity providers by calling
    /// with 0 amount{0,1} and sending the donation amount(s) from the callback
    /// @param recipient The address which will receive the token0 and token1 amounts
    /// @param amount0 The amount of token0 to send
    /// @param amount1 The amount of token1 to send
    /// @param data Any data to be passed through to the callback
    function flash(
        address recipient,
        uint256 amount0,
        uint256 amount1,
        bytes calldata data
    ) external;

    /// @notice Increase the maximum number of price and liquidity observations that this pool will store
    /// @dev This method is no-op if the pool already has an observationCardinalityNext greater than or equal to
    /// the input observationCardinalityNext.
    /// @param observationCardinalityNext The desired minimum number of observations for the pool to store
    function increaseObservationCardinalityNext(uint16 observationCardinalityNext) external;
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Pool state that is not stored
/// @notice Contains view functions to provide information about the pool that is computed rather than stored on the
/// blockchain. The functions here may have variable gas costs.
interface IUniswapV3PoolDerivedState {
    /// @notice Returns the cumulative tick and liquidity as of each timestamp `secondsAgo` from the current block timestamp
    /// @dev To get a time weighted average tick or liquidity-in-range, you must call this with two values, one representing
    /// the beginning of the period and another for the end of the period. E.g., to get the last hour time-weighted average tick,
    /// you must call it with secondsAgos = [3600, 0].
    /// @dev The time weighted average tick represents the geometric time weighted average price of the pool, in
    /// log base sqrt(1.0001) of token1 / token0. The TickMath library can be used to go from a tick value to a ratio.
    /// @param secondsAgos From how long ago each cumulative tick and liquidity value should be returned
    /// @return tickCumulatives Cumulative tick values as of each `secondsAgos` from the current block timestamp
    /// @return secondsPerLiquidityCumulativeX128s Cumulative seconds per liquidity-in-range value as of each `secondsAgos` from the current block
    /// timestamp
    function observe(uint32[] calldata secondsAgos)
        external
        view
        returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);

    /// @notice Returns a snapshot of the tick cumulative, seconds per liquidity and seconds inside a tick range
    /// @dev Snapshots must only be compared to other snapshots, taken over a period for which a position existed.
    /// I.e., snapshots cannot be compared if a position is not held for the entire period between when the first
    /// snapshot is taken and the second snapshot is taken.
    /// @param tickLower The lower tick of the range
    /// @param tickUpper The upper tick of the range
    /// @return tickCumulativeInside The snapshot of the tick accumulator for the range
    /// @return secondsPerLiquidityInsideX128 The snapshot of seconds per liquidity for the range
    /// @return secondsInside The snapshot of seconds per liquidity for the range
    function snapshotCumulativesInside(int24 tickLower, int24 tickUpper)
        external
        view
        returns (
            int56 tickCumulativeInside,
            uint160 secondsPerLiquidityInsideX128,
            uint32 secondsInside
        );
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Errors emitted by a pool
/// @notice Contains all events emitted by the pool
interface IUniswapV3PoolErrors {
    error LOK();
    error TLU();
    error TLM();
    error TUM();
    error AI();
    error M0();
    error M1();
    error AS();
    error IIA();
    error L();
    error F0();
    error F1();
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Events emitted by a pool
/// @notice Contains all events emitted by the pool
interface IUniswapV3PoolEvents {
    /// @notice Emitted exactly once by a pool when #initialize is first called on the pool
    /// @dev Mint/Burn/Swap cannot be emitted by the pool before Initialize
    /// @param sqrtPriceX96 The initial sqrt price of the pool, as a Q64.96
    /// @param tick The initial tick of the pool, i.e. log base 1.0001 of the starting price of the pool
    event Initialize(uint160 sqrtPriceX96, int24 tick);

    /// @notice Emitted when liquidity is minted for a given position
    /// @param sender The address that minted the liquidity
    /// @param owner The owner of the position and recipient of any minted liquidity
    /// @param tickLower The lower tick of the position
    /// @param tickUpper The upper tick of the position
    /// @param amount The amount of liquidity minted to the position range
    /// @param amount0 How much token0 was required for the minted liquidity
    /// @param amount1 How much token1 was required for the minted liquidity
    event Mint(
        address sender,
        address indexed owner,
        int24 indexed tickLower,
        int24 indexed tickUpper,
        uint128 amount,
        uint256 amount0,
        uint256 amount1
    );

    /// @notice Emitted when fees are collected by the owner of a position
    /// @dev Collect events may be emitted with zero amount0 and amount1 when the caller chooses not to collect fees
    /// @param owner The owner of the position for which fees are collected
    /// @param tickLower The lower tick of the position
    /// @param tickUpper The upper tick of the position
    /// @param amount0 The amount of token0 fees collected
    /// @param amount1 The amount of token1 fees collected
    event Collect(
        address indexed owner,
        address recipient,
        int24 indexed tickLower,
        int24 indexed tickUpper,
        uint128 amount0,
        uint128 amount1
    );

    /// @notice Emitted when a position's liquidity is removed
    /// @dev Does not withdraw any fees earned by the liquidity position, which must be withdrawn via #collect
    /// @param owner The owner of the position for which liquidity is removed
    /// @param tickLower The lower tick of the position
    /// @param tickUpper The upper tick of the position
    /// @param amount The amount of liquidity to remove
    /// @param amount0 The amount of token0 withdrawn
    /// @param amount1 The amount of token1 withdrawn
    event Burn(
        address indexed owner,
        int24 indexed tickLower,
        int24 indexed tickUpper,
        uint128 amount,
        uint256 amount0,
        uint256 amount1
    );

    /// @notice Emitted by the pool for any swaps between token0 and token1
    /// @param sender The address that initiated the swap call, and that received the callback
    /// @param recipient The address that received the output of the swap
    /// @param amount0 The delta of the token0 balance of the pool
    /// @param amount1 The delta of the token1 balance of the pool
    /// @param sqrtPriceX96 The sqrt(price) of the pool after the swap, as a Q64.96
    /// @param liquidity The liquidity of the pool after the swap
    /// @param tick The log base 1.0001 of price of the pool after the swap
    event Swap(
        address indexed sender,
        address indexed recipient,
        int256 amount0,
        int256 amount1,
        uint160 sqrtPriceX96,
        uint128 liquidity,
        int24 tick
    );

    /// @notice Emitted by the pool for any flashes of token0/token1
    /// @param sender The address that initiated the swap call, and that received the callback
    /// @param recipient The address that received the tokens from flash
    /// @param amount0 The amount of token0 that was flashed
    /// @param amount1 The amount of token1 that was flashed
    /// @param paid0 The amount of token0 paid for the flash, which can exceed the amount0 plus the fee
    /// @param paid1 The amount of token1 paid for the flash, which can exceed the amount1 plus the fee
    event Flash(
        address indexed sender,
        address indexed recipient,
        uint256 amount0,
        uint256 amount1,
        uint256 paid0,
        uint256 paid1
    );

    /// @notice Emitted by the pool for increases to the number of observations that can be stored
    /// @dev observationCardinalityNext is not the observation cardinality until an observation is written at the index
    /// just before a mint/swap/burn.
    /// @param observationCardinalityNextOld The previous value of the next observation cardinality
    /// @param observationCardinalityNextNew The updated value of the next observation cardinality
    event IncreaseObservationCardinalityNext(
        uint16 observationCardinalityNextOld,
        uint16 observationCardinalityNextNew
    );

    /// @notice Emitted when the protocol fee is changed by the pool
    /// @param feeProtocol0Old The previous value of the token0 protocol fee
    /// @param feeProtocol1Old The previous value of the token1 protocol fee
    /// @param feeProtocol0New The updated value of the token0 protocol fee
    /// @param feeProtocol1New The updated value of the token1 protocol fee
    event SetFeeProtocol(uint8 feeProtocol0Old, uint8 feeProtocol1Old, uint8 feeProtocol0New, uint8 feeProtocol1New);

    /// @notice Emitted when the collected protocol fees are withdrawn by the factory owner
    /// @param sender The address that collects the protocol fees
    /// @param recipient The address that receives the collected protocol fees
    /// @param amount0 The amount of token0 protocol fees that is withdrawn
    /// @param amount0 The amount of token1 protocol fees that is withdrawn
    event CollectProtocol(address indexed sender, address indexed recipient, uint128 amount0, uint128 amount1);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Pool state that never changes
/// @notice These parameters are fixed for a pool forever, i.e., the methods will always return the same values
interface IUniswapV3PoolImmutables {
    /// @notice The contract that deployed the pool, which must adhere to the IUniswapV3Factory interface
    /// @return The contract address
    function factory() external view returns (address);

    /// @notice The first of the two tokens of the pool, sorted by address
    /// @return The token contract address
    function token0() external view returns (address);

    /// @notice The second of the two tokens of the pool, sorted by address
    /// @return The token contract address
    function token1() external view returns (address);

    /// @notice The pool's fee in hundredths of a bip, i.e. 1e-6
    /// @return The fee
    function fee() external view returns (uint24);

    /// @notice The pool tick spacing
    /// @dev Ticks can only be used at multiples of this value, minimum of 1 and always positive
    /// e.g.: a tickSpacing of 3 means ticks can be initialized every 3rd tick, i.e., ..., -6, -3, 0, 3, 6, ...
    /// This value is an int24 to avoid casting even though it is always positive.
    /// @return The tick spacing
    function tickSpacing() external view returns (int24);

    /// @notice The maximum amount of position liquidity that can use any tick in the range
    /// @dev This parameter is enforced per tick to prevent liquidity from overflowing a uint128 at any point, and
    /// also prevents out-of-range liquidity from being used to prevent adding in-range liquidity to a pool
    /// @return The max amount of liquidity per tick
    function maxLiquidityPerTick() external view returns (uint128);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Permissioned pool actions
/// @notice Contains pool methods that may only be called by the factory owner
interface IUniswapV3PoolOwnerActions {
    /// @notice Set the denominator of the protocol's % share of the fees
    /// @param feeProtocol0 new protocol fee for token0 of the pool
    /// @param feeProtocol1 new protocol fee for token1 of the pool
    function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external;

    /// @notice Collect the protocol fee accrued to the pool
    /// @param recipient The address to which collected protocol fees should be sent
    /// @param amount0Requested The maximum amount of token0 to send, can be 0 to collect fees in only token1
    /// @param amount1Requested The maximum amount of token1 to send, can be 0 to collect fees in only token0
    /// @return amount0 The protocol fee collected in token0
    /// @return amount1 The protocol fee collected in token1
    function collectProtocol(
        address recipient,
        uint128 amount0Requested,
        uint128 amount1Requested
    ) external returns (uint128 amount0, uint128 amount1);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Pool state that can change
/// @notice These methods compose the pool's state, and can change with any frequency including multiple times
/// per transaction
interface IUniswapV3PoolState {
    /// @notice The 0th storage slot in the pool stores many values, and is exposed as a single method to save gas
    /// when accessed externally.
    /// @return sqrtPriceX96 The current price of the pool as a sqrt(token1/token0) Q64.96 value
    /// @return tick The current tick of the pool, i.e. according to the last tick transition that was run.
    /// This value may not always be equal to SqrtTickMath.getTickAtSqrtRatio(sqrtPriceX96) if the price is on a tick
    /// boundary.
    /// @return observationIndex The index of the last oracle observation that was written,
    /// @return observationCardinality The current maximum number of observations stored in the pool,
    /// @return observationCardinalityNext The next maximum number of observations, to be updated when the observation.
    /// @return feeProtocol The protocol fee for both tokens of the pool.
    /// Encoded as two 4 bit values, where the protocol fee of token1 is shifted 4 bits and the protocol fee of token0
    /// is the lower 4 bits. Used as the denominator of a fraction of the swap fee, e.g. 4 means 1/4th of the swap fee.
    /// unlocked Whether the pool is currently locked to reentrancy
    function slot0()
        external
        view
        returns (
            uint160 sqrtPriceX96,
            int24 tick,
            uint16 observationIndex,
            uint16 observationCardinality,
            uint16 observationCardinalityNext,
            uint8 feeProtocol,
            bool unlocked
        );

    /// @notice The fee growth as a Q128.128 fees of token0 collected per unit of liquidity for the entire life of the pool
    /// @dev This value can overflow the uint256
    function feeGrowthGlobal0X128() external view returns (uint256);

    /// @notice The fee growth as a Q128.128 fees of token1 collected per unit of liquidity for the entire life of the pool
    /// @dev This value can overflow the uint256
    function feeGrowthGlobal1X128() external view returns (uint256);

    /// @notice The amounts of token0 and token1 that are owed to the protocol
    /// @dev Protocol fees will never exceed uint128 max in either token
    function protocolFees() external view returns (uint128 token0, uint128 token1);

    /// @notice The currently in range liquidity available to the pool
    /// @dev This value has no relationship to the total liquidity across all ticks
    /// @return The liquidity at the current price of the pool
    function liquidity() external view returns (uint128);

    /// @notice Look up information about a specific tick in the pool
    /// @param tick The tick to look up
    /// @return liquidityGross the total amount of position liquidity that uses the pool either as tick lower or
    /// tick upper
    /// @return liquidityNet how much liquidity changes when the pool price crosses the tick,
    /// @return feeGrowthOutside0X128 the fee growth on the other side of the tick from the current tick in token0,
    /// @return feeGrowthOutside1X128 the fee growth on the other side of the tick from the current tick in token1,
    /// @return tickCumulativeOutside the cumulative tick value on the other side of the tick from the current tick
    /// @return secondsPerLiquidityOutsideX128 the seconds spent per liquidity on the other side of the tick from the current tick,
    /// @return secondsOutside the seconds spent on the other side of the tick from the current tick,
    /// @return initialized Set to true if the tick is initialized, i.e. liquidityGross is greater than 0, otherwise equal to false.
    /// Outside values can only be used if the tick is initialized, i.e. if liquidityGross is greater than 0.
    /// In addition, these values are only relative and must be used only in comparison to previous snapshots for
    /// a specific position.
    function ticks(int24 tick)
        external
        view
        returns (
            uint128 liquidityGross,
            int128 liquidityNet,
            uint256 feeGrowthOutside0X128,
            uint256 feeGrowthOutside1X128,
            int56 tickCumulativeOutside,
            uint160 secondsPerLiquidityOutsideX128,
            uint32 secondsOutside,
            bool initialized
        );

    /// @notice Returns 256 packed tick initialized boolean values. See TickBitmap for more information
    function tickBitmap(int16 wordPosition) external view returns (uint256);

    /// @notice Returns the information about a position by the position's key
    /// @param key The position's key is a hash of a preimage composed by the owner, tickLower and tickUpper
    /// @return liquidity The amount of liquidity in the position,
    /// @return feeGrowthInside0LastX128 fee growth of token0 inside the tick range as of the last mint/burn/poke,
    /// @return feeGrowthInside1LastX128 fee growth of token1 inside the tick range as of the last mint/burn/poke,
    /// @return tokensOwed0 the computed amount of token0 owed to the position as of the last mint/burn/poke,
    /// @return tokensOwed1 the computed amount of token1 owed to the position as of the last mint/burn/poke
    function positions(bytes32 key)
        external
        view
        returns (
            uint128 liquidity,
            uint256 feeGrowthInside0LastX128,
            uint256 feeGrowthInside1LastX128,
            uint128 tokensOwed0,
            uint128 tokensOwed1
        );

    /// @notice Returns data about a specific observation index
    /// @param index The element of the observations array to fetch
    /// @dev You most likely want to use #observe() instead of this method to get an observation as of some amount of time
    /// ago, rather than at a specific index in the array.
    /// @return blockTimestamp The timestamp of the observation,
    /// @return tickCumulative the tick multiplied by seconds elapsed for the life of the pool as of the observation timestamp,
    /// @return secondsPerLiquidityCumulativeX128 the seconds per in range liquidity for the life of the pool as of the observation timestamp,
    /// @return initialized whether the observation has been initialized and the values are safe to use
    function observations(uint256 index)
        external
        view
        returns (
            uint32 blockTimestamp,
            int56 tickCumulative,
            uint160 secondsPerLiquidityCumulativeX128,
            bool initialized
        );
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Callback for IUniswapV3PoolActions#swap
/// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface
interface IUniswapV3SwapCallback {
    /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap.
    /// @dev In the implementation you must pay the pool tokens owed for the swap.
    /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
    /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
    /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by
    /// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
    /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by
    /// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
    /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call
    function uniswapV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external;
}

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

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

/// @title Interface for WETH9
interface IWETH9 is IERC20 {
    /// @notice Deposit ether to get wrapped ether
    function deposit() external payable;

    /// @notice Withdraw wrapped ether to get ether
    function withdraw(uint256) external;
}

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

pragma solidity ^0.8.20;

import {Panic} from "../Panic.sol";
import {SafeCast} from "./SafeCast.sol";

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
     *
     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
     * one branch when needed, making this function more expensive.
     */
    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            // branchless ternary works because:
            // b ^ (a ^ b) == a
            // b ^ 0 == b
            return b ^ ((a ^ b) * SafeCast.toUint(condition));
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return ternary(a > b, a, b);
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return ternary(a < b, a, b);
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }

        // The following calculation ensures accurate ceiling division without overflow.
        // Since a is non-zero, (a - 1) / b will not overflow.
        // The largest possible result occurs when (a - 1) / b is type(uint256).max,
        // but the largest value we can obtain is type(uint256).max - 1, which happens
        // when a = type(uint256).max and b = 1.
        unchecked {
            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
        }
    }

    /**
     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     *
     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use
            // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2²⁵⁶ + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
            if (denominator <= prod1) {
                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
            inverse *= 2 - denominator * inverse; // inverse mod 2³²
            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is
            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
    }

    /**
     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
     *
     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
     *
     * If the input value is not inversible, 0 is returned.
     *
     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
     */
    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
        unchecked {
            if (n == 0) return 0;

            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
            // Used to compute integers x and y such that: ax + ny = gcd(a, n).
            // When the gcd is 1, then the inverse of a modulo n exists and it's x.
            // ax + ny = 1
            // ax = 1 + (-y)n
            // ax ≡ 1 (mod n) # x is the inverse of a modulo n

            // If the remainder is 0 the gcd is n right away.
            uint256 remainder = a % n;
            uint256 gcd = n;

            // Therefore the initial coefficients are:
            // ax + ny = gcd(a, n) = n
            // 0a + 1n = n
            int256 x = 0;
            int256 y = 1;

            while (remainder != 0) {
                uint256 quotient = gcd / remainder;

                (gcd, remainder) = (
                    // The old remainder is the next gcd to try.
                    remainder,
                    // Compute the next remainder.
                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
                    // where gcd is at most n (capped to type(uint256).max)
                    gcd - remainder * quotient
                );

                (x, y) = (
                    // Increment the coefficient of a.
                    y,
                    // Decrement the coefficient of n.
                    // Can overflow, but the result is casted to uint256 so that the
                    // next value of y is "wrapped around" to a value between 0 and n - 1.
                    x - y * int256(quotient)
                );
            }

            if (gcd != 1) return 0; // No inverse exists.
            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
        }
    }

    /**
     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
     *
     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.
     *
     * NOTE: this function does NOT check that `p` is a prime greater than `2`.
     */
    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
        unchecked {
            return Math.modExp(a, p - 2, p);
        }
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
     *
     * Requirements:
     * - modulus can't be zero
     * - underlying staticcall to precompile must succeed
     *
     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
     * sure the chain you're using it on supports the precompiled contract for modular exponentiation
     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly
     * interpreted as 0.
     */
    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
        (bool success, uint256 result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
     * to operate modulo 0 or if the underlying precompile reverted.
     *
     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
     * of a revert, but the result may be incorrectly interpreted as 0.
     */
    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
        if (m == 0) return (false, 0);
        assembly ("memory-safe") {
            let ptr := mload(0x40)
            // | Offset    | Content    | Content (Hex)                                                      |
            // |-----------|------------|--------------------------------------------------------------------|
            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x60:0x7f | value of b | 0x<.............................................................b> |
            // | 0x80:0x9f | value of e | 0x<.............................................................e> |
            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |
            mstore(ptr, 0x20)
            mstore(add(ptr, 0x20), 0x20)
            mstore(add(ptr, 0x40), 0x20)
            mstore(add(ptr, 0x60), b)
            mstore(add(ptr, 0x80), e)
            mstore(add(ptr, 0xa0), m)

            // Given the result < m, it's guaranteed to fit in 32 bytes,
            // so we can use the memory scratch space located at offset 0.
            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
            result := mload(0x00)
        }
    }

    /**
     * @dev Variant of {modExp} that supports inputs of arbitrary length.
     */
    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
        (bool success, bytes memory result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.
     */
    function tryModExp(
        bytes memory b,
        bytes memory e,
        bytes memory m
    ) internal view returns (bool success, bytes memory result) {
        if (_zeroBytes(m)) return (false, new bytes(0));

        uint256 mLen = m.length;

        // Encode call args in result and move the free memory pointer
        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);

        assembly ("memory-safe") {
            let dataPtr := add(result, 0x20)
            // Write result on top of args to avoid allocating extra memory.
            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
            // Overwrite the length.
            // result.length > returndatasize() is guaranteed because returndatasize() == m.length
            mstore(result, mLen)
            // Set the memory pointer after the returned data.
            mstore(0x40, add(dataPtr, mLen))
        }
    }

    /**
     * @dev Returns whether the provided byte array is zero.
     */
    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
        for (uint256 i = 0; i < byteArray.length; ++i) {
            if (byteArray[i] != 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only
     * using integer operations.
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        unchecked {
            // Take care of easy edge cases when a == 0 or a == 1
            if (a <= 1) {
                return a;
            }

            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
            // the current value as `ε_n = | x_n - sqrt(a) |`.
            //
            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
            // bigger than any uint256.
            //
            // By noticing that
            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
            // to the msb function.
            uint256 aa = a;
            uint256 xn = 1;

            if (aa >= (1 << 128)) {
                aa >>= 128;
                xn <<= 64;
            }
            if (aa >= (1 << 64)) {
                aa >>= 64;
                xn <<= 32;
            }
            if (aa >= (1 << 32)) {
                aa >>= 32;
                xn <<= 16;
            }
            if (aa >= (1 << 16)) {
                aa >>= 16;
                xn <<= 8;
            }
            if (aa >= (1 << 8)) {
                aa >>= 8;
                xn <<= 4;
            }
            if (aa >= (1 << 4)) {
                aa >>= 4;
                xn <<= 2;
            }
            if (aa >= (1 << 2)) {
                xn <<= 1;
            }

            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
            //
            // We can refine our estimation by noticing that the middle of that interval minimizes the error.
            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
            // This is going to be our x_0 (and ε_0)
            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)

            // From here, Newton's method give us:
            // x_{n+1} = (x_n + a / x_n) / 2
            //
            // One should note that:
            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
            //              = ((x_n² + a) / (2 * x_n))² - a
            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
            //              = (x_n² - a)² / (2 * x_n)²
            //              = ((x_n² - a) / (2 * x_n))²
            //              ≥ 0
            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
            //
            // This gives us the proof of quadratic convergence of the sequence:
            // ε_{n+1} = | x_{n+1} - sqrt(a) |
            //         = | (x_n + a / x_n) / 2 - sqrt(a) |
            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
            //         = | (x_n - sqrt(a))² / (2 * x_n) |
            //         = | ε_n² / (2 * x_n) |
            //         = ε_n² / | (2 * x_n) |
            //
            // For the first iteration, we have a special case where x_0 is known:
            // ε_1 = ε_0² / | (2 * x_0) |
            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))
            //     ≤ 2**(e-3) / 3
            //     ≤ 2**(e-3-log2(3))
            //     ≤ 2**(e-4.5)
            //
            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
            // ε_{n+1} = ε_n² / | (2 * x_n) |
            //         ≤ (2**(e-k))² / (2 * 2**(e-1))
            //         ≤ 2**(2*e-2*k) / 2**e
            //         ≤ 2**(e-2*k)
            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above
            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5
            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9
            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18
            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36
            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72

            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
            // sqrt(a) or sqrt(a) + 1.
            return xn - SafeCast.toUint(xn > a / xn);
        }
    }

    /**
     * @dev Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 x) internal pure returns (uint256 r) {
        // If value has upper 128 bits set, log2 result is at least 128
        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;
        // If upper 64 bits of 128-bit half set, add 64 to result
        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;
        // If upper 32 bits of 64-bit half set, add 32 to result
        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;
        // If upper 16 bits of 32-bit half set, add 16 to result
        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;
        // If upper 8 bits of 16-bit half set, add 8 to result
        r |= SafeCast.toUint((x >> r) > 0xff) << 3;
        // If upper 4 bits of 8-bit half set, add 4 to result
        r |= SafeCast.toUint((x >> r) > 0xf) << 2;

        // Shifts value right by the current result and use it as an index into this lookup table:
        //
        // | x (4 bits) |  index  | table[index] = MSB position |
        // |------------|---------|-----------------------------|
        // |    0000    |    0    |        table[0] = 0         |
        // |    0001    |    1    |        table[1] = 0         |
        // |    0010    |    2    |        table[2] = 1         |
        // |    0011    |    3    |        table[3] = 1         |
        // |    0100    |    4    |        table[4] = 2         |
        // |    0101    |    5    |        table[5] = 2         |
        // |    0110    |    6    |        table[6] = 2         |
        // |    0111    |    7    |        table[7] = 2         |
        // |    1000    |    8    |        table[8] = 3         |
        // |    1001    |    9    |        table[9] = 3         |
        // |    1010    |   10    |        table[10] = 3        |
        // |    1011    |   11    |        table[11] = 3        |
        // |    1100    |   12    |        table[12] = 3        |
        // |    1101    |   13    |        table[13] = 3        |
        // |    1110    |   14    |        table[14] = 3        |
        // |    1111    |   15    |        table[15] = 3        |
        //
        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.
        assembly ("memory-safe") {
            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))
        }
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        uint256 isGt;
        unchecked {
            isGt = SafeCast.toUint(value > (1 << 128) - 1);
            value >>= isGt * 128;
            result += isGt * 16;

            isGt = SafeCast.toUint(value > (1 << 64) - 1);
            value >>= isGt * 64;
            result += isGt * 8;

            isGt = SafeCast.toUint(value > (1 << 32) - 1);
            value >>= isGt * 32;
            result += isGt * 4;

            isGt = SafeCast.toUint(value > (1 << 16) - 1);
            value >>= isGt * 16;
            result += isGt * 2;

            result += SafeCast.toUint(value > (1 << 8) - 1);
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}