Contract Address Details

// SPDX-License-Identifier: CC-BY-NC-ND-4.0
pragma solidity ^0.8.0;
pragma abicoder v2;

import "../UniswapV3/open-zeppelin/token/ERC721/ERC721Holder.sol";
import "../UniswapV3/open-zeppelin/token/ERC20/IERC20.sol";
import "../UniswapV3/v3-periphery/libraries/LiquidityAmounts.sol";
import "./TickMath.sol";
import "./ReentrancyGuard.sol";
import "./TransferHelper.sol";

 
contract ElectroSwapLockerV3 is ERC721Holder, ReentrancyGuard {
    
    INonfungiblePositionManager private immutable positionManager;
    address private immutable boltAddress;
    address private immutable deadAddress = address(0x000000000000000000000000000000000000dEaD);
    address payable private teamWallet;

    mapping(uint256 => LockInfo) private lockedPositions;
    mapping(address => uint256[]) private ownerToLocks;
    mapping(address => uint256[]) private poolToLocks;
    mapping(address => bool) private noFeeList;

    struct LockInfo {
        uint256 tokenId;
        address owner;
        uint256 created;
        uint256 duration;
        bool active;
        address token0;
        address token1;
        uint24 fee;
        uint256 lockedAmount0; 
        uint256 lockedAmount1;
        address pool;
        uint256 poolAmount0; 
        uint256 poolAmount1;
    }

    struct Fees {
        uint etnFlatFee; // Amount of ETN paid as lock creation fee to stop spam
        uint boltFlatFee; // Amount of BOLT to be burned when paying lock creation fee in BOLT
        uint128 lpPercentFee; // Platform fee as a percentage of locked ElectroSwap LP tokens
    }

    Fees public fees; // Stores the current fee structure
    IMigrator private migrator;

    modifier onlyTeam() {
        require(msg.sender == teamWallet, "Only contract owner can call this function");
        _;
    }

    constructor(address _positionManager, address _boltAddress) {
        positionManager = INonfungiblePositionManager(_positionManager);
        teamWallet = payable(msg.sender);
        boltAddress = _boltAddress;

        fees.etnFlatFee = 1000; // 1000 ETN
        fees.boltFlatFee = 500; // 500 BOLT
        fees.lpPercentFee = 1; // 1%
    }


    // Owner must first approve this contract to interact with the LP position NFT by calling approve on the NFT Position Manager
    function lockPosition(uint256 tokenId, uint256 lockDuration, bool _flatFeeInETN) external payable nonReentrant returns (bool success){
        require(lockDuration > 0, "Lock duration must be greater than zero");
        require(!lockedPositions[tokenId].active, "Position already locked");

        // Transfer the NFT to the locker contract
        positionManager.safeTransferFrom(msg.sender, address(this), tokenId);
        (,,address token0, address token1, uint24 fee,,,uint128 liquidity,,,,) = positionManager.positions(tokenId);
        
        //Process fees if applicable
        if (!noFeeList[msg.sender]) {

            // Process flat fee
            if (_flatFeeInETN) { // Flat rate fee to be paid in ETN
                require(msg.value == (fees.etnFlatFee * 1e18), "Flat rate ETN fee not met");
                (bool etnTransferSuccess, ) = teamWallet.call{value: msg.value}("");
                require(etnTransferSuccess, "Failed to transfer ETN");
            } else { // Flat rate fee to be paid in BOLT Token, and then burned
                TransferHelper.safeTransferFrom(boltAddress, msg.sender, deadAddress, (fees.boltFlatFee * 1e18));
            }

            // Process percentage of liquidity fee
            // Check if fees are collectable, if they are, then revert to ensure we don't collect more than the percent fee
            (uint256 amount0Collected, uint256 amount1Collected) = _collect(tokenId, address(this));
            require(amount0Collected == 0 && amount1Collected == 0, "Must collect fees before locking");

            // Decrease liquidity by fee percent
            
            INonfungiblePositionManager.DecreaseLiquidityParams memory params = INonfungiblePositionManager.DecreaseLiquidityParams({
                tokenId: tokenId,
                liquidity: (liquidity * fees.lpPercentFee) / 100, // 1% of total liquidity in position to be removed
                amount0Min: 0,
                amount1Min: 0,
                deadline: block.timestamp + 60 // 1 minute deadline
            });
            positionManager.decreaseLiquidity(params);
            
            //Collect percentage fee to team wallet
            (amount0Collected, amount1Collected) = _collect(tokenId, teamWallet);
            require(amount0Collected > 0 || amount1Collected > 0, "Sufficient fee not paid");

        } else if (msg.value > 0){
            // refund ETN if whitelisted
            (bool etnRefundSuccess, ) = payable(msg.sender).call{value: msg.value}("");
            require(etnRefundSuccess, "Failed to refund ETN");
        }

        address poolAddress = IElectroSwapV3Factory(positionManager.factory()).getPool(token0, token1, fee);
        require(poolAddress != address(0), "ElectroSwap pool does not exist");

        lockedPositions[tokenId] = LockInfo({
            tokenId: tokenId,
            owner: msg.sender,
            created: block.timestamp,
            duration: lockDuration,
            active: true,
            token0: token0,
            token1: token1,
            fee: fee,
            lockedAmount0: 0, // amounts are transient - populated at time of retrieval
            lockedAmount1: 0,
            pool: poolAddress,
            poolAmount0: 0,
            poolAmount1: 0
        });

        ownerToLocks[msg.sender].push(tokenId);
        poolToLocks[poolAddress].push(tokenId);

        emit LockedV3(msg.sender, tokenId, block.timestamp, lockDuration, poolAddress, token0, token1);

        return true;
    }

    function unlockPosition(uint256 tokenId) external nonReentrant {
        LockInfo memory lockInfo = lockedPositions[tokenId];
        require(lockInfo.active, "Position not locked");
        require(msg.sender == lockInfo.owner, "Only the owner can unlock");
        require(block.timestamp >= (lockInfo.created + lockInfo.duration), "Position still locked");

        delete lockedPositions[tokenId];
        removeLockId(true, lockInfo.owner, tokenId);
        removeLockId(false, lockInfo.pool, tokenId);

        // Transfer the NFT back to the owner
        positionManager.safeTransferFrom(address(this), lockInfo.owner, tokenId);

        emit UnlockedV3(lockInfo.owner, tokenId);
    }

    function withdrawFees(uint256 tokenId) external nonReentrant {
        LockInfo memory lockInfo = lockedPositions[tokenId];
        require(lockInfo.active, "Position not locked");
        require(msg.sender == lockInfo.owner, "Only the owner can withdraw fees");

        (uint256 amount0, uint256 amount1) = _collect(tokenId, lockInfo.owner);

        emit FeesWithdrawnV3(lockInfo.owner, tokenId, amount0, amount1);
    }

    // Caller must first approve this LP Locker contract in the amounts passed in for each of the ERC-20 tokens requesting to be added to the Liquidity Pool
    function increaseLiquidity(uint256 tokenId, uint256 amount0Desired, uint256 amount1Desired) external nonReentrant {
        LockInfo memory lockInfo = lockedPositions[tokenId];
        require(lockInfo.active, "Position not locked");
        require(msg.sender == lockInfo.owner, "Only the owner can increase liquidity");

        // Transfer tokens from the original owner to the contract
        IERC20(lockInfo.token0).transferFrom(msg.sender, address(this), amount0Desired);
        IERC20(lockInfo.token1).transferFrom(msg.sender, address(this), amount1Desired);

        // Approve the position manager to spend tokens
        IERC20(lockInfo.token0).approve(address(positionManager), amount0Desired);
        IERC20(lockInfo.token1).approve(address(positionManager), amount1Desired);

        // Increase liquidity
        INonfungiblePositionManager.IncreaseLiquidityParams memory params = INonfungiblePositionManager.IncreaseLiquidityParams({
            tokenId: tokenId,
            amount0Desired: amount0Desired,
            amount1Desired: amount1Desired,
            amount0Min: 0,
            amount1Min: 0,
            deadline: block.timestamp + 60 // 1 minute deadline
        });
        (uint128 addedLiquidity, uint256 amount0Actual, uint256 amount1Actual) = positionManager.increaseLiquidity(params);

        // Return any unspent tokens to the original owner
        if (amount0Actual < amount0Desired) {
            IERC20(lockInfo.token0).transfer(msg.sender, amount0Desired - amount0Actual);
        }
        if (amount1Actual < amount1Desired) {
            IERC20(lockInfo.token1).transfer(msg.sender, amount1Desired - amount1Actual);
        }

        emit LiquidityIncreasedV3(lockInfo.owner, tokenId, addedLiquidity, amount0Actual, amount1Actual);
    }

    function extendLock(uint256 tokenId, uint256 additionalDuration) external nonReentrant {
        LockInfo storage lockInfo = lockedPositions[tokenId];
        require(lockInfo.active, "Position not locked");
        require(msg.sender == lockInfo.owner, "Only the owner can extend the lock");

        lockInfo.duration += additionalDuration;

        emit LockExtendedV3(lockInfo.owner, tokenId, lockInfo.created, lockInfo.duration);
    }

    function splitLock( uint256 tokenId, uint128 percentLiquidityToNewLock, uint256 durationPastOriginal) external nonReentrant {
        LockInfo memory lockInfo = lockedPositions[tokenId];
        require(lockInfo.active, "Position not locked");
        require(msg.sender == lockInfo.owner, "Only the owner can split the lock");
        require(percentLiquidityToNewLock < 100 && percentLiquidityToNewLock > 0, "Invalid percentage");

        // Check if fees are collectable, if they are, then revert to ensure we don't collect more than the percent fee
        (uint256 amount0Collected, uint256 amount1Collected) = _collect(tokenId, address(this));
        require(amount0Collected == 0 && amount1Collected == 0, "Must collect fees before splitting lock");

        (,,,,, int24 tickLower, int24 tickUpper, uint128 liquidity,,,,) = positionManager.positions(tokenId);

        // Step 1: Decrease liquidity
        INonfungiblePositionManager.DecreaseLiquidityParams memory decreaseParams = INonfungiblePositionManager.DecreaseLiquidityParams({
            tokenId: tokenId,
            liquidity: (liquidity * percentLiquidityToNewLock) / 100,
            amount0Min: 0,
            amount1Min: 0,
            deadline: block.timestamp + 60
        });
        positionManager.decreaseLiquidity(decreaseParams);

        // Step 2: Collect tokens from decreased liquidity
        (amount0Collected, amount1Collected) = _collect(tokenId, address(this));

        // Step 3: Create new position with removed liquidity
        IERC20(lockInfo.token0).approve(address(positionManager), amount0Collected);
        IERC20(lockInfo.token1).approve(address(positionManager), amount1Collected);

        INonfungiblePositionManager.MintParams memory mintParams = INonfungiblePositionManager.MintParams({
            token0: lockInfo.token0,
            token1: lockInfo.token1,
            fee: lockInfo.fee,
            tickLower: tickLower,
            tickUpper: tickUpper,
            amount0Desired: amount0Collected,
            amount1Desired: amount1Collected,
            amount0Min: 0,
            amount1Min: 0,
            recipient: address(this),
            deadline: block.timestamp + 60
        });
        (uint256 newTokenId, , , ) = positionManager.mint(mintParams);

        // Step 4: Lock the new position
        uint newDuration = (lockInfo.created + lockInfo.duration + durationPastOriginal - block.timestamp);
        lockedPositions[newTokenId] = LockInfo({
            tokenId: newTokenId,
            owner: lockInfo.owner,
            created: block.timestamp,
            duration: newDuration,
            active: true,
            token0: lockInfo.token0,
            token1: lockInfo.token1,
            fee: lockInfo.fee,
            lockedAmount0: 0, // amounts are transient - populated at time of retrieval
            lockedAmount1: 0,
            pool: lockInfo.pool,
            poolAmount0: 0,
            poolAmount1: 0
        });
        ownerToLocks[msg.sender].push(newTokenId);
        poolToLocks[lockInfo.pool].push(newTokenId);

        // emit an event
        emit LockSplitV3(lockInfo.owner, tokenId, newTokenId, block.timestamp, newDuration);
    }

    function transferLockOwner(uint256 tokenId, address newOwner) external nonReentrant returns (bool success) {
        LockInfo storage lockInfo = lockedPositions[tokenId];
        require(msg.sender == lockInfo.owner, "Only the owner can transfer the lock to new owner");
        require(newOwner != address(0), "New owner cannot be zero address");
        
        address oldOwner = lockInfo.owner;
        lockInfo.owner = newOwner;

        removeLockId(true, oldOwner, tokenId);
        ownerToLocks[newOwner].push(tokenId);

        emit LockTransferredV3(tokenId, oldOwner, newOwner);

        return true;
    }

    // To be used in future if Uniswap V4 type liquidity support is added
    function migrateLock(uint tokenId) external nonReentrant {
        require(address(migrator) != address(0), "Migrator not set");

        LockInfo storage lockInfo = lockedPositions[tokenId];
        require(lockInfo.active, "Position not locked");
        require(lockInfo.owner == msg.sender, "Only the owner can migrate the lock");
        
        // Transfer the NFT to the Migrator
        positionManager.safeTransferFrom(address(this), address(migrator), tokenId);

        // Attempt to migrate the lock
        require(migrator.migrate(lockInfo.pool, lockInfo.owner, tokenId, lockInfo.created, lockInfo.duration), "Migration failed");

        delete lockedPositions[tokenId];
        removeLockId(true, lockInfo.owner, tokenId);
        removeLockId(false, lockInfo.pool, tokenId);

        emit LockMigratedFromV3(tokenId);
    }

    function getLockById(uint256 tokenId) external view returns (LockInfo memory lockInfo) {
        lockInfo = lockedPositions[tokenId];
        require(lockInfo.active, "No lock exists");

        (,,,,, int24 tickLower, int24 tickUpper, uint128 liquidity,,,,) = positionManager.positions(tokenId);

        IElectroSwapV3Pool pool = IElectroSwapV3Pool(lockInfo.pool);
        (uint160 sqrtPriceX96,,,,,,) = pool.slot0();
        uint128 poolLiquidity = pool.liquidity();

        (uint256 amount0, uint256 amount1) = LiquidityAmounts.getAmountsForLiquidity(
            sqrtPriceX96,
            TickMath.getSqrtRatioAtTick(tickLower),
            TickMath.getSqrtRatioAtTick(tickUpper),
            liquidity
        );

        (uint256 poolAmount0, uint256 poolAmount1) = LiquidityAmounts.getAmountsForLiquidity(
            sqrtPriceX96,
            TickMath.getSqrtRatioAtTick(TickMath.MIN_TICK),
            TickMath.getSqrtRatioAtTick(TickMath.MAX_TICK),
            poolLiquidity
        );

        lockInfo.lockedAmount0 = amount0;
        lockInfo.lockedAmount1 = amount1;
        lockInfo.poolAmount0 = poolAmount0;
        lockInfo.poolAmount1 = poolAmount1;

        return lockInfo;
    }

    function getLockIdsByOwner(address owner) external view returns (uint256[] memory) {
        return ownerToLocks[owner];
    }

    function getLockIdsByPool(address poolAddress) external view returns (uint256[] memory) {
        return poolToLocks[poolAddress];
    }


    function _collect(uint256 tokenId, address recipient) internal returns (uint256 amount0Collected, uint256 amount1Collected) {
        INonfungiblePositionManager.CollectParams memory collectParams = INonfungiblePositionManager.CollectParams({
            tokenId: tokenId,
            recipient: recipient, 
            amount0Max: type(uint128).max,
            amount1Max: type(uint128).max
        });
        (amount0Collected, amount1Collected) = positionManager.collect(collectParams);
    }

    function removeLockId(bool _owner, address _address, uint256 _lockIdToRemove) internal {
        uint256[] storage values = _owner ? ownerToLocks[_address] : poolToLocks[_address];
        uint256 length = values.length;

        // Find the index of the value to be removed
        for (uint256 i = 0; i < length; i++) {
            if (values[i] == _lockIdToRemove) {
                // Shift elements to the left to fill the gap
                for (uint256 j = i; j < length - 1; j++) {
                    values[j] = values[j + 1];
                }
                // Remove the last element
                values.pop();
                break;
            }
        }
    }

    function adminSetFees(uint _etnFlatFee, uint _boltFlatFee, uint128 _lpPercentFee) external onlyTeam {
        require(_etnFlatFee <= 2000, "Flat fee cannot be greater than 2000 ETN");
        require(_boltFlatFee <= 1000, "Flat fee cannot be greater than 1000 BOLT");
        require(_lpPercentFee <= 2, "LP percentage cannot be greater than 2%");

        fees.etnFlatFee = _etnFlatFee;
        fees.boltFlatFee = _boltFlatFee;
        fees.lpPercentFee = _lpPercentFee;

        emit LockerFeesUpdated(_etnFlatFee, _boltFlatFee, _lpPercentFee);
    }

    function adminSetTeamWallet(address payable _teamWallet) external onlyTeam {
        require(_teamWallet != address(0), "Team wallet cannot be zero address");
        teamWallet = _teamWallet;
        emit TeamWalletUpdated(_teamWallet);
    }

    function adminUpdateFeeWhitelist(address _address, bool _whitelisted) external onlyTeam {
        noFeeList[_address] = _whitelisted;
        emit FeeWhitelistUpdated(_address, _whitelisted);
    }

    function adminSetMigrator(IMigrator _migrator) external onlyTeam {
        migrator = _migrator;
        emit MigratorUpdated(address(_migrator));
    }


    event LockedV3(address indexed owner, uint256 indexed tokenId, uint256 created, uint256 duration, address poolAddress, address token0, address token1);
    event UnlockedV3(address indexed owner, uint256 indexed tokenId);
    event FeesWithdrawnV3(address indexed owner, uint256 indexed tokenId, uint256 amount0, uint256 amount1);
    event LiquidityIncreasedV3(address indexed owner, uint256 indexed tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
    event LockExtendedV3(address indexed owner, uint256 indexed tokenId, uint256 created, uint256 newDuration);
    event LockSplitV3(address indexed owner, uint256 indexed existingTokenId, uint256 indexed newTokenId, uint256 created, uint256 newDuration);
    event LockTransferredV3(uint256 indexed tokenId, address indexed oldOwner, address indexed newOwner);
    event LockMigratedFromV3(uint256 indexed tokenId);
    
    // Team/admin events
    event LockerFeesUpdated(uint256 etnFlatFee, uint boltFlatFee, uint128 lpPercentFee);
    event FeeWhitelistUpdated(address _address, bool whitelisted);
    event TeamWalletUpdated(address indexed newTeamWallet);
    event MigratorUpdated(address indexed migratorAddress);
}


interface IMigrator {
    function migrate(address poolAddress, address owner, uint256 tokenId, uint256 lockCreated, uint256 lockDuration) external returns (bool);
}

interface IElectroSwapV3Factory {
    function getPool(address tokenA, address tokenB, uint24 fee) external view returns (address pool);
}

interface IElectroSwapV3Pool {
    function slot0() external view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked);
    function liquidity() external view returns (uint128 poolLiquidity);
}

interface INonfungiblePositionManager {
    
    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;
    }

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

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

    function decreaseLiquidity(DecreaseLiquidityParams calldata params)
        external
        payable
        returns (uint256 amount0, uint256 amount1);

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

    function collect(CollectParams calldata params) external payable returns (uint256 amount0, uint256 amount1);

    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    function factory() external view returns (address factory);
}
        

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721Receiver.sol";

  /**
   * @dev Implementation of the {IERC721Receiver} interface.
   *
   * Accepts all token transfers. 
   * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}.
   */
contract ERC721Holder is IERC721Receiver {

    /**
     * @dev See {IERC721Receiver-onERC721Received}.
     *
     * Always returns `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(address, address, uint256, bytes memory) public virtual override returns (bytes4) {
        return this.onERC721Received.selector;
    }
}
          

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 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 `IERC721.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.4.0;

/// @title FixedPoint96
/// @notice A library for handling binary fixed point numbers, see https://en.wikipedia.org/wiki/Q_(number_format)
/// @dev Used in SqrtPriceMath.sol
library FixedPoint96 {
    uint8 internal constant RESOLUTION = 96;
    uint256 internal constant Q96 = 0x1000000000000000000000000;
}
          

// 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
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}
          

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

/// @title Math library for computing sqrt prices from ticks and vice versa
/// @notice Computes sqrt price for ticks of size 1.0001, i.e. sqrt(1.0001^tick) as fixed point Q64.96 numbers. Supports
/// prices between 2**-128 and 2**128
library TickMath {
    error T();
    error R();

    /// @dev The minimum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**-128
    int24 internal constant MIN_TICK = -887272;
    /// @dev The maximum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**128
    int24 internal constant MAX_TICK = -MIN_TICK;

    /// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK)
    uint160 internal constant MIN_SQRT_RATIO = 4295128739;
    /// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK)
    uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;

    /// @notice Calculates sqrt(1.0001^tick) * 2^96
    /// @dev Throws if |tick| > max tick
    /// @param tick The input tick for the above formula
    /// @return sqrtPriceX96 A Fixed point Q64.96 number representing the sqrt of the ratio of the two assets (token1/token0)
    /// at the given tick
    function getSqrtRatioAtTick(int24 tick) internal pure returns (uint160 sqrtPriceX96) {
        unchecked {
            uint256 absTick = tick < 0 ? uint256(-int256(tick)) : uint256(int256(tick));
            if (absTick > uint256(int256(MAX_TICK))) revert T();

            uint256 ratio = absTick & 0x1 != 0
                ? 0xfffcb933bd6fad37aa2d162d1a594001
                : 0x100000000000000000000000000000000;
            if (absTick & 0x2 != 0) ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
            if (absTick & 0x4 != 0) ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
            if (absTick & 0x8 != 0) ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
            if (absTick & 0x10 != 0) ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
            if (absTick & 0x20 != 0) ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
            if (absTick & 0x40 != 0) ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
            if (absTick & 0x80 != 0) ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
            if (absTick & 0x100 != 0) ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
            if (absTick & 0x200 != 0) ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
            if (absTick & 0x400 != 0) ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
            if (absTick & 0x800 != 0) ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
            if (absTick & 0x1000 != 0) ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
            if (absTick & 0x2000 != 0) ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
            if (absTick & 0x4000 != 0) ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
            if (absTick & 0x8000 != 0) ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
            if (absTick & 0x10000 != 0) ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
            if (absTick & 0x20000 != 0) ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
            if (absTick & 0x40000 != 0) ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
            if (absTick & 0x80000 != 0) ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;

            if (tick > 0) ratio = type(uint256).max / ratio;

            // this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
            // we then downcast because we know the result always fits within 160 bits due to our tick input constraint
            // we round up in the division so getTickAtSqrtRatio of the output price is always consistent
            sqrtPriceX96 = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1));
        }
    }

    /// @notice Calculates the greatest tick value such that getRatioAtTick(tick) <= ratio
    /// @dev Throws in case sqrtPriceX96 < MIN_SQRT_RATIO, as MIN_SQRT_RATIO is the lowest value getRatioAtTick may
    /// ever return.
    /// @param sqrtPriceX96 The sqrt ratio for which to compute the tick as a Q64.96
    /// @return tick The greatest tick for which the ratio is less than or equal to the input ratio
    function getTickAtSqrtRatio(uint160 sqrtPriceX96) internal pure returns (int24 tick) {
        unchecked {
            // second inequality must be < because the price can never reach the price at the max tick
            if (!(sqrtPriceX96 >= MIN_SQRT_RATIO && sqrtPriceX96 < MAX_SQRT_RATIO)) revert R();
            uint256 ratio = uint256(sqrtPriceX96) << 32;

            uint256 r = ratio;
            uint256 msb = 0;

            assembly {
                let f := shl(7, gt(r, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
                msb := or(msb, f)
                r := shr(f, r)
            }
            assembly {
                let f := shl(6, gt(r, 0xFFFFFFFFFFFFFFFF))
                msb := or(msb, f)
                r := shr(f, r)
            }
            assembly {
                let f := shl(5, gt(r, 0xFFFFFFFF))
                msb := or(msb, f)
                r := shr(f, r)
            }
            assembly {
                let f := shl(4, gt(r, 0xFFFF))
                msb := or(msb, f)
                r := shr(f, r)
            }
            assembly {
                let f := shl(3, gt(r, 0xFF))
                msb := or(msb, f)
                r := shr(f, r)
            }
            assembly {
                let f := shl(2, gt(r, 0xF))
                msb := or(msb, f)
                r := shr(f, r)
            }
            assembly {
                let f := shl(1, gt(r, 0x3))
                msb := or(msb, f)
                r := shr(f, r)
            }
            assembly {
                let f := gt(r, 0x1)
                msb := or(msb, f)
            }

            if (msb >= 128) r = ratio >> (msb - 127);
            else r = ratio << (127 - msb);

            int256 log_2 = (int256(msb) - 128) << 64;

            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(63, f))
                r := shr(f, r)
            }
            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(62, f))
                r := shr(f, r)
            }
            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(61, f))
                r := shr(f, r)
            }
            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(60, f))
                r := shr(f, r)
            }
            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(59, f))
                r := shr(f, r)
            }
            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(58, f))
                r := shr(f, r)
            }
            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(57, f))
                r := shr(f, r)
            }
            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(56, f))
                r := shr(f, r)
            }
            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(55, f))
                r := shr(f, r)
            }
            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(54, f))
                r := shr(f, r)
            }
            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(53, f))
                r := shr(f, r)
            }
            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(52, f))
                r := shr(f, r)
            }
            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(51, f))
                r := shr(f, r)
            }
            assembly {
                r := shr(127, mul(r, r))
                let f := shr(128, r)
                log_2 := or(log_2, shl(50, f))
            }

            int256 log_sqrt10001 = log_2 * 255738958999603826347141; // 128.128 number

            int24 tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);
            int24 tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);

            tick = tickLow == tickHi ? tickLow : getSqrtRatioAtTick(tickHi) <= sqrtPriceX96 ? tickHi : tickLow;
        }
    }
}
          

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

// helper methods for interacting with ERC20 tokens that do not consistently return true/false
library TransferHelper {
    function safeApprove(address token, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
    }

    function safeTransfer(address token, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

    function safeTransferFrom(address token, address from, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
    }

}
          

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}
          

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

import '../../v3-core/libraries/FullMath.sol';
import '../../v3-core/libraries/FixedPoint96.sol';

/// @title Liquidity amount functions
/// @notice Provides functions for computing liquidity amounts from token amounts and prices
library LiquidityAmounts {
    /// @notice Downcasts uint256 to uint128
    /// @param x The uint258 to be downcasted
    /// @return y The passed value, downcasted to uint128
    function toUint128(uint256 x) private pure returns (uint128 y) {
        require((y = uint128(x)) == x);
    }

    /// @notice Computes the amount of liquidity received for a given amount of token0 and price range
    /// @dev Calculates amount0 * (sqrt(upper) * sqrt(lower)) / (sqrt(upper) - sqrt(lower))
    /// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
    /// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
    /// @param amount0 The amount0 being sent in
    /// @return liquidity The amount of returned liquidity
    function getLiquidityForAmount0(
        uint160 sqrtRatioAX96,
        uint160 sqrtRatioBX96,
        uint256 amount0
    ) internal pure returns (uint128 liquidity) {
        if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
        uint256 intermediate = FullMath.mulDiv(sqrtRatioAX96, sqrtRatioBX96, FixedPoint96.Q96);
        return toUint128(FullMath.mulDiv(amount0, intermediate, sqrtRatioBX96 - sqrtRatioAX96));
    }

    /// @notice Computes the amount of liquidity received for a given amount of token1 and price range
    /// @dev Calculates amount1 / (sqrt(upper) - sqrt(lower)).
    /// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
    /// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
    /// @param amount1 The amount1 being sent in
    /// @return liquidity The amount of returned liquidity
    function getLiquidityForAmount1(
        uint160 sqrtRatioAX96,
        uint160 sqrtRatioBX96,
        uint256 amount1
    ) internal pure returns (uint128 liquidity) {
        if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
        return toUint128(FullMath.mulDiv(amount1, FixedPoint96.Q96, sqrtRatioBX96 - sqrtRatioAX96));
    }

    /// @notice Computes the maximum amount of liquidity received for a given amount of token0, token1, the current
    /// pool prices and the prices at the tick boundaries
    /// @param sqrtRatioX96 A sqrt price representing the current pool prices
    /// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
    /// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
    /// @param amount0 The amount of token0 being sent in
    /// @param amount1 The amount of token1 being sent in
    /// @return liquidity The maximum amount of liquidity received
    function getLiquidityForAmounts(
        uint160 sqrtRatioX96,
        uint160 sqrtRatioAX96,
        uint160 sqrtRatioBX96,
        uint256 amount0,
        uint256 amount1
    ) internal pure returns (uint128 liquidity) {
        if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);

        if (sqrtRatioX96 <= sqrtRatioAX96) {
            liquidity = getLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, amount0);
        } else if (sqrtRatioX96 < sqrtRatioBX96) {
            uint128 liquidity0 = getLiquidityForAmount0(sqrtRatioX96, sqrtRatioBX96, amount0);
            uint128 liquidity1 = getLiquidityForAmount1(sqrtRatioAX96, sqrtRatioX96, amount1);

            liquidity = liquidity0 < liquidity1 ? liquidity0 : liquidity1;
        } else {
            liquidity = getLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1);
        }
    }

    /// @notice Computes the amount of token0 for a given amount of liquidity and a price range
    /// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
    /// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
    /// @param liquidity The liquidity being valued
    /// @return amount0 The amount of token0
    function getAmount0ForLiquidity(
        uint160 sqrtRatioAX96,
        uint160 sqrtRatioBX96,
        uint128 liquidity
    ) internal pure returns (uint256 amount0) {
        if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);

        return
            FullMath.mulDiv(
                uint256(liquidity) << FixedPoint96.RESOLUTION,
                sqrtRatioBX96 - sqrtRatioAX96,
                sqrtRatioBX96
            ) / sqrtRatioAX96;
    }

    /// @notice Computes the amount of token1 for a given amount of liquidity and a price range
    /// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
    /// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
    /// @param liquidity The liquidity being valued
    /// @return amount1 The amount of token1
    function getAmount1ForLiquidity(
        uint160 sqrtRatioAX96,
        uint160 sqrtRatioBX96,
        uint128 liquidity
    ) internal pure returns (uint256 amount1) {
        if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);

        return FullMath.mulDiv(liquidity, sqrtRatioBX96 - sqrtRatioAX96, FixedPoint96.Q96);
    }

    /// @notice Computes the token0 and token1 value for a given amount of liquidity, the current
    /// pool prices and the prices at the tick boundaries
    /// @param sqrtRatioX96 A sqrt price representing the current pool prices
    /// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
    /// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
    /// @param liquidity The liquidity being valued
    /// @return amount0 The amount of token0
    /// @return amount1 The amount of token1
    function getAmountsForLiquidity(
        uint160 sqrtRatioX96,
        uint160 sqrtRatioAX96,
        uint160 sqrtRatioBX96,
        uint128 liquidity
    ) internal pure returns (uint256 amount0, uint256 amount1) {
        if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);

        if (sqrtRatioX96 <= sqrtRatioAX96) {
            amount0 = getAmount0ForLiquidity(sqrtRatioAX96, sqrtRatioBX96, liquidity);
        } else if (sqrtRatioX96 < sqrtRatioBX96) {
            amount0 = getAmount0ForLiquidity(sqrtRatioX96, sqrtRatioBX96, liquidity);
            amount1 = getAmount1ForLiquidity(sqrtRatioAX96, sqrtRatioX96, liquidity);
        } else {
            amount1 = getAmount1ForLiquidity(sqrtRatioAX96, sqrtRatioBX96, liquidity);
        }
    }
}