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

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

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

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

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

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

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

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

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

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

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

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

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

import {IMaverickV2Pool} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Pool.sol";
import {PackLib} from "../libraries/PackLib.sol";
import {IArgPacker} from "./IArgPacker.sol";

/**
 * @notice View functions that pack and unpack addLiquidity parameters.
 */
abstract contract ArgPacker is IArgPacker {
    /// @inheritdoc IArgPacker
    function unpackAddLiquidityArgs(
        bytes memory argsPacked
    ) public pure returns (IMaverickV2Pool.AddLiquidityParams memory args) {
        return PackLib.unpackAddLiquidityArgs(argsPacked);
    }

    /// @inheritdoc IArgPacker
    function packAddLiquidityArgs(
        IMaverickV2Pool.AddLiquidityParams memory args
    ) public pure returns (bytes memory argsPacked) {
        return PackLib.packAddLiquidityArgs(args);
    }

    /// @inheritdoc IArgPacker
    function packAddLiquidityArgsArray(
        IMaverickV2Pool.AddLiquidityParams[] memory args
    ) public pure returns (bytes[] memory argsPacked) {
        return PackLib.packAddLiquidityArgsArray(args);
    }

    /// @inheritdoc IArgPacker
    function unpackUint88Array(bytes memory packedArray) public pure returns (uint88[] memory fullArray) {
        fullArray = PackLib.unpackUint88Array(packedArray);
    }

    /// @inheritdoc IArgPacker
    function packUint88Array(uint88[] memory fullArray) public pure returns (bytes memory packedArray) {
        packedArray = PackLib.packArray(fullArray);
    }
}

// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.25;

// Adapted from https://github.com/GNSPS/solidity-bytes-utils/blob/1dff13ef21304eb3634cb9e7f86c119cf280bd35/contracts/BytesLib.sol
library BytesLib {
    error BytesLibToBoolOutOfBounds();
    error BytesLibToAddressOutOfBounds();
    error BytesLibSliceOverflow();
    error BytesLibSliceOutOfBounds();
    error BytesLibInvalidLength(uint256 inputLength, uint256 expectedLength);

    function slice(bytes memory _bytes, uint256 _start, uint256 _length) internal pure returns (bytes memory) {
        // 31 is added to _length in assembly; need to check here that that
        // operation will not overflow
        if (_length > type(uint256).max - 31) revert BytesLibSliceOverflow();
        if (_bytes.length < _start + _length) revert BytesLibSliceOutOfBounds();

        bytes memory tempBytes;

        assembly ("memory-safe") {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)
                //zero out the 32 bytes slice we are about to return
                //we need to do it because Solidity does not garbage collect
                mstore(tempBytes, 0)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }

    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address addr) {
        unchecked {
            if (_bytes.length < _start + 20) revert BytesLibToAddressOutOfBounds();

            assembly ("memory-safe") {
                addr := and(0xffffffffffffffffffffffffffffffffffffffff, mload(add(add(_bytes, 20), _start)))
            }
        }
    }

    function toBool(bytes memory _bytes, uint256 _start) internal pure returns (bool) {
        unchecked {
            if (_bytes.length < _start + 1) revert BytesLibToBoolOutOfBounds();
            uint8 tempUint;

            assembly ("memory-safe") {
                tempUint := mload(add(add(_bytes, 1), _start))
            }

            return tempUint == 1;
        }
    }

    function toAddressAddressBoolUint128Uint128(
        bytes memory _bytes
    ) internal pure returns (address addr1, address addr2, bool bool_, uint128 amount1, uint128 amount2) {
        if (_bytes.length != 73) revert BytesLibInvalidLength(_bytes.length, 73);
        uint8 temp;
        assembly ("memory-safe") {
            addr1 := and(0xffffffffffffffffffffffffffffffffffffffff, mload(add(_bytes, 20)))
            addr2 := and(0xffffffffffffffffffffffffffffffffffffffff, mload(add(_bytes, 40)))
            temp := mload(add(_bytes, 41))
            amount1 := and(0xffffffffffffffffffffffffffffffff, mload(add(_bytes, 57)))
            amount2 := and(0xffffffffffffffffffffffffffffffff, mload(add(_bytes, 73)))
        }
        bool_ = temp == 1;
    }
}

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

import {IMaverickV2Pool} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Pool.sol";
import {IChecks} from "./IChecks.sol";
import {PoolInspection} from "../libraries/PoolInspection.sol";

abstract contract Checks is IChecks {
    /// @inheritdoc IChecks
    function checkSqrtPrice(IMaverickV2Pool pool, uint256 minSqrtPrice, uint256 maxSqrtPrice) public payable {
        uint256 sqrtPrice = PoolInspection.poolSqrtPrice(pool);
        if (sqrtPrice < minSqrtPrice || sqrtPrice > maxSqrtPrice)
            revert PositionExceededPriceBounds(sqrtPrice, minSqrtPrice, maxSqrtPrice);
    }

    /// @inheritdoc IChecks
    function checkDeadline(uint256 deadline) public payable {
        if (block.timestamp > deadline) revert PositionDeadlinePassed(deadline, block.timestamp);
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
// As the copyright holder of this work, Ubiquity Labs retains
// the right to distribute, use, and modify this code under any license of
// their choosing, in addition to the terms of the GPL-v2 or later.
pragma solidity ^0.8.25;

// factory contraints on pools
uint8 constant MAX_PROTOCOL_FEE_RATIO_D3 = 0.25e3; // 25%
uint256 constant MAX_PROTOCOL_LENDING_FEE_RATE_D18 = 0.02e18; // 2%
uint64 constant MAX_POOL_FEE_D18 = 0.9e18; // 90%
uint64 constant MIN_LOOKBACK = 1 seconds;
uint64 constant MAX_TICK_SPACING = 10_000;

// pool constraints
uint8 constant NUMBER_OF_KINDS = 4;
int32 constant NUMBER_OF_KINDS_32 = int32(int8(NUMBER_OF_KINDS));
uint256 constant MAX_TICK = 322_378; // max price 1e14 in D18 scale
int32 constant MAX_TICK_32 = int32(int256(MAX_TICK));
int32 constant MIN_TICK_32 = int32(-int256(MAX_TICK));
uint256 constant MAX_BINS_TO_MERGE = 3;
uint128 constant MINIMUM_LIQUIDITY = 1e8;

// accessor named constants
uint8 constant ALL_KINDS_MASK = 0xF; // 0b1111
uint8 constant PERMISSIONED_LIQUIDITY_MASK = 0x10; // 0b010000
uint8 constant PERMISSIONED_SWAP_MASK = 0x20; // 0b100000
uint8 constant OPTIONS_MASK = ALL_KINDS_MASK | PERMISSIONED_LIQUIDITY_MASK | PERMISSIONED_SWAP_MASK; // 0b111111

// named values
address constant MERGED_LP_BALANCE_ADDRESS = address(0);
uint256 constant MERGED_LP_BALANCE_SUBACCOUNT = 0;
uint128 constant ONE = 1e18;
uint128 constant ONE_SQUARED = 1e36;
int256 constant INT256_ONE = 1e18;
uint256 constant ONE_D8 = 1e8;
uint256 constant ONE_D3 = 1e3;
int40 constant INT_ONE_D8 = 1e8;
int40 constant HALF_TICK_D8 = 0.5e8;
uint8 constant DEFAULT_DECIMALS = 18;
uint256 constant DEFAULT_SCALE = 1;
bytes constant EMPTY_PRICE_BREAKS = hex"010000000000000000000000";

// 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.0.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 ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
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}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * 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:
     * ```
     * 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: GPL-2.0-or-later
pragma solidity ^0.8.25;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IMaverickV2Pool} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Pool.sol";

import {Payment} from "../paymentbase/Payment.sol";
import {IExactOutputSlim} from "./IExactOutputSlim.sol";
import {Swap} from "./Swap.sol";

abstract contract ExactOutputSlim is Payment, Swap, IExactOutputSlim {
    /**
     * @dev Callback function called by Maverick V2 pools when swapping tokens.
     * @param tokenIn The input token.
     * @param amountToPay The amount to pay.
     * @param data Additional data.
     */
    function maverickV2SwapCallback(
        IERC20 tokenIn,
        uint256 amountToPay,
        uint256,
        bytes calldata data
    ) external virtual {
        if (!factory().isFactoryPool(IMaverickV2Pool(msg.sender))) revert RouterNotFactoryPool();
        address payer = abi.decode(data, (address));
        if (amountToPay != 0) pay(tokenIn, payer, msg.sender, amountToPay);
    }

    /**
     * @dev Perform a swap with an exact output amount.
     * @param recipient The recipient of the swapped tokens.
     * @param pool The MaverickV2 pool to use for the swap.
     * @param tokenAIn Whether token A is the input token.
     * @param amountOut The exact output amount.
     * @param tickLimit The tick limit for the swap.
     * @return amountIn The input amount required to achieve the exact output.
     * @return amountOut_ The actual output amount received from the swap.
     */
    function exactOutputSingleMinimal(
        address recipient,
        IMaverickV2Pool pool,
        bool tokenAIn,
        uint256 amountOut,
        int32 tickLimit
    ) public payable returns (uint256 amountIn, uint256 amountOut_) {
        (amountIn, amountOut_) = _exactOutputSingleWithTickCheck(pool, recipient, amountOut, tokenAIn, tickLimit);
    }

    /**
     * @dev Perform an exact output single swap with tick limit validation.
     * @param pool The MaverickV2 pool to use for the swap.
     * @param recipient The recipient of the swapped tokens.
     * @param amountOut The exact output amount.
     * @param tokenAIn Whether token A is the input token.
     * @param tickLimit The tick limit for the swap.
     * @return amountIn The input amount required to achieve the exact output.
     * @return _amountOut The actual output amount received from the swap.
     */
    function _exactOutputSingleWithTickCheck(
        IMaverickV2Pool pool,
        address recipient,
        uint256 amountOut,
        bool tokenAIn,
        int32 tickLimit
    ) internal returns (uint256 amountIn, uint256 _amountOut) {
        IMaverickV2Pool.SwapParams memory swapParams = IMaverickV2Pool.SwapParams({
            amount: amountOut,
            tokenAIn: tokenAIn,
            exactOutput: true,
            tickLimit: tickLimit
        });
        (amountIn, _amountOut) = _swap(
            pool,
            (recipient == address(0)) ? address(this) : recipient,
            swapParams,
            abi.encode(msg.sender)
        );
    }
}

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

import {IMaverickV2Pool} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Pool.sol";

interface IArgPacker {
    /**
     * @notice Packs addLiquidity paramters into a bytes object.  The packing
     * is [kind, ticksArray, amountsArray] where the arrays are packed like
     * this: [length, array[0], array[1],..., array[length-1]]. length is 1
     * byte (256 total possible elements).
     */
    function packAddLiquidityArgs(
        IMaverickV2Pool.AddLiquidityParams memory args
    ) external pure returns (bytes memory argsPacked);

    /**
     * @notice Unpacks packed addLiquidity parameters.
     */
    function unpackAddLiquidityArgs(
        bytes memory argsPacked
    ) external pure returns (IMaverickV2Pool.AddLiquidityParams memory args);

    /**
     * @notice Packs addLiquidity paramters array element-wise.
     */
    function packAddLiquidityArgsArray(
        IMaverickV2Pool.AddLiquidityParams[] memory args
    ) external pure returns (bytes[] memory argsPacked);

    /**
     * @notice Packs sqrtPrice breaks array with this format: [length,
     * array[0], array[1],..., array[length-1]] where length is 1 byte.

     */
    function packUint88Array(uint88[] memory fullArray) external pure returns (bytes memory packedArray);

    /**
     * @notice Unpacks sqrtPrice breaks bytes object into array.
     */
    function unpackUint88Array(bytes memory packedArray) external pure returns (uint88[] memory fullArray);
}

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

import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";

import {IMaverickV2Pool} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Pool.sol";
import {IMulticall} from "@maverick/v2-common/contracts/base/IMulticall.sol";

import {IChecks} from "../base/IChecks.sol";

interface IBoostedPositionBase is IERC20Metadata, IChecks, IMulticall {
    /**
     * @notice BP Pool.
     */
    function pool() external view returns (IMaverickV2Pool pool_);

    /**
     * @notice BP Bin kind (static, right, left, both).
     */
    function kind() external view returns (uint8 kind_);

    /**
     * @notice Number of bins in the BP.
     */
    function binCount() external view returns (uint8 binCount_);

    /**
     * @notice Liquidity balance in BP bins since last mint/burn operation.
     */
    function getBinBalances() external view returns (uint128[] memory binBalances_);

    /**
     * @notice Liquidity balance in given BP bin since last mint/burn
     * operation.
     */
    function binBalances(uint256 index) external view returns (uint128 binBalance);
}

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

import {IMaverickV2Pool} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Pool.sol";

interface IChecks {
    error PositionExceededPriceBounds(uint256 sqrtPrice, uint256 minSqrtPrice, uint256 maxSqrtPrice);
    error PositionDeadlinePassed(uint256 deadline, uint256 blockTimestamp);

    /**
     * @notice Function to check if the price of a pool is within specified bounds.
     * @param pool The MaverickV2Pool contract to check.
     * @param minSqrtPrice The minimum acceptable square root price.
     * @param maxSqrtPrice The maximum acceptable square root price.
     */
    function checkSqrtPrice(IMaverickV2Pool pool, uint256 minSqrtPrice, uint256 maxSqrtPrice) external payable;

    /**
     * @notice Function to check if a given deadline has passed.
     * @param deadline The timestamp representing the deadline.
     */
    function checkDeadline(uint256 deadline) external payable;
}

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

pragma solidity ^0.8.20;

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

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

/**
 * @dev Interface for the optional metadata functions from the ERC20 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.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

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

pragma solidity ^0.8.20;

interface IERC6372 {
    /**
     * @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based checkpoints (and voting).
     */
    function clock() external view returns (uint48);

    /**
     * @dev Description of the clock
     */
    // solhint-disable-next-line func-name-mixedcase
    function CLOCK_MODE() external view returns (string memory);
}

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

pragma solidity ^0.8.20;

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

/**
 * @dev Required interface of an ERC721 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 ERC721 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 ERC721
     * 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: GPL-2.0-or-later
pragma solidity ^0.8.25;

import {IMaverickV2Pool} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Pool.sol";

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

interface IExactOutputSlim is IRouterErrors {
    function exactOutputSingleMinimal(
        address recipient,
        IMaverickV2Pool pool,
        bool tokenAIn,
        uint256 amountOut,
        int32 tickLimit
    ) external payable returns (uint256 amountIn, uint256 amountOut_);
}

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

interface IHistoricalBalance {
    /**
     * @notice This function retrieves the historical balance of an account at
     * a specific point in time.
     * @param account The address of the account for which to retrieve the
     * historical balance.
     * @param timepoint The timepoint (block number or timestamp depending on
     * implementation) at which to query the balance (uint256).
     * @return balance The balance of the account at the specified timepoint.
     */
    function getPastBalanceOf(address account, uint256 timepoint) external view returns (uint256 balance);
}

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

import {IBoostedPositionBase} from "../boostedpositionbase/IBoostedPositionBase.sol";

interface IMaverickV2BoostedPosition is IBoostedPositionBase {
    event BoostedPositionMigrateBinLiquidity(uint32 currentBinId, uint32 newBinId, uint128 newBinBalance);

    error BoostedPositionTooLittleLiquidityAdded(uint256 binIdIndex, uint32 binId, uint128 required, uint128 available);
    error BoostedPositionMovementBinNotMigrated();

    /**
     * @notice Mints BP LP position to recipient.  User has to add liquidity to
     * BP contract before making this call as this mint function simply assigns
     * any new liquidity that this BP possesses in the pool to the recipient.
     * Accordingly, this function should only be called in the same transaction
     * where liquidity has been added to a pool as part of a multicall or
     * through a router/manager contract.
     */
    function mint(address recipient) external returns (uint256 deltaSupply);

    /**
     * @notice Burns BP LP positions and redeems the underlying A/B token to the recipient.
     */
    function burn(address recipient, uint256 amount) external returns (uint256 tokenAOut, uint256 tokenBOut);

    /**
     * @notice Migrates all underlying movement-mode liquidity from a merged
     * bin to the active parent of the merged bin.  For Static BPs, this
     * function is a no-op and never needs to be called.
     */
    function migrateBinLiquidityToRoot() external;

    /**
     * @notice Array of ticks where the underlying BP liquidity exists.
     */
    function getTicks() external view returns (int32[] memory ticks);

    /**
     * @notice Array of relative pool bin LP balance of the bins in the BP.
     */
    function getRatios() external view returns (uint128[] memory ratios_);

    /**
     * @notice Array of BP binIds.  Will revert if the BP is a movement mode
     * and the underlying bin is merged.
     */
    function getBinIds() external view returns (uint32[] memory binIds_);

    /**
     * @notice Array of BP binIds.  Will not revert if the BP is a movement mode
     * and the underlying bin is merged.  For statis BPs, this returns the same
     * value as `getBinIds`.
     */
    function getRawBinIds() external view returns (uint32[] memory);

    /**
     * @notice Removes excess liquidity from the binId[0] bin and sends to
     * recipient. Skimming is desirable if there is more than one bin in the BP
     * and the skimmable amount is non-zero.
     * Skimming amount is only applicable if the number of bins is more than
     * one.  For single-bin BPs, a user can effectively "skim" by minting BP
     * tokens to themselves.
     */
    function skim(address recipient) external returns (uint256 tokenAOut, uint256 tokenBOut);

    /**
     * @notice Returns the amount of binIds[0] LP balance that is skimmable in
     * the BP.  If this number is non-zero, it is desirable to skim before
     * minting to ensure that the ratio solvency checks pass.  Checking the
     * skimmable amount is only applicable if the number of bins is more than
     * one.  For single-bin BPs, a user can effectively "skim" by minting BP
     * tokens to themselves.
     */
    function skimmableAmount() external view returns (uint128 amount);
}

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

import {IMaverickV2Factory} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Factory.sol";
import {IMaverickV2Pool} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Pool.sol";

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

interface IMaverickV2BoostedPositionFactory {
    error BoostedPositionFactoryNotFactoryPool();
    error BoostedPositionPermissionedLiquidityPool();
    error BoostedPositionFactoryKindNotSupportedByPool(uint8 poolKinds, uint8 kind);
    error BoostedPositionFactoryInvalidRatioZero(uint128 ratioZero);
    error BoostedPositionFactoryInvalidLengths(uint256 ratioLength, uint256 binIdsLength);
    error BoostedPositionFactoryInvalidLengthForKind(uint8 kind, uint256 ratiosLength);
    error BoostedPositionFactoryBinIdsNotSorted(uint256 index, uint32 lastBinId, uint32 thisBinId);
    error BoostedPositionFactoryInvalidBinKind(uint8 inputKind, uint8 binKind, uint32 binId);

    event CreateBoostedPosition(
        IMaverickV2Pool pool,
        uint32[] binIds,
        uint128[] ratios,
        uint8 kind,
        IMaverickV2BoostedPosition boostedPosition
    );

    /**
     * @notice Creates BP from the specified input parameters.  Requirements:
     *
     * - Pool must be from pool factory
     * - BP kind must be supported by the pool
     * - BinIds have to be sorted in ascending order
     * - ratios[0] must be 1e18; ratios are specified in D18 scale
     * - ratio and binId arrays have to be the same length
     * - movement-mode BPs can only have one binId
     * - static-mode BPs can have at most 24 binIds
     */
    function createBoostedPosition(
        IMaverickV2Pool pool,
        uint32[] memory binIds,
        uint128[] memory ratios,
        uint8 kind
    ) external returns (IMaverickV2BoostedPosition boostedPosition);

    /**
     * @notice Look up BPs by range of indexes.
     */
    function lookup(uint256 startIndex, uint256 endIndex) external view returns (IMaverickV2BoostedPosition[] memory);

    /**
     * @notice Returns count of all BPs deployed by the factory.
     */
    function boostedPositionsCount() external view returns (uint256 count);

    /**
     * @notice Look up BPs by range of indexes for a given pool.
     */
    function lookup(
        IMaverickV2Pool pool,
        uint256 startIndex,
        uint256 endIndex
    ) external view returns (IMaverickV2BoostedPosition[] memory);

    /**
     * @notice Returns count of all BPs deployed by the factory for a given
     * pool.
     */
    function boostedPositionsByPoolCount(IMaverickV2Pool pool) external view returns (uint256 count);

    /**
     * @notice Returns whether or not input BP was created by this factory.
     */
    function isFactoryBoostedPosition(IMaverickV2BoostedPosition) external returns (bool);

    /**
     * @notice Pool factory that all BPs pool must be deployed from.
     */
    function poolFactory() external returns (IMaverickV2Factory);
}

// SPDX-License-Identifier: GPL-2.0-or-later
// As the copyright holder of this work, Ubiquity Labs retains
// the right to distribute, use, and modify this code under any license of
// their choosing, in addition to the terms of the GPL-v2 or later.
pragma solidity ^0.8.25;

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

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

interface IMaverickV2Factory {
    error FactoryInvalidProtocolFeeRatio(uint8 protocolFeeRatioD3);
    error FactoryInvalidLendingFeeRate(uint256 protocolLendingFeeRateD18);
    error FactoryProtocolFeeOnRenounce(uint8 protocolFeeRatioD3);
    error FactorAlreadyInitialized();
    error FactorNotInitialized();
    error FactoryInvalidTokenOrder(IERC20 _tokenA, IERC20 _tokenB);
    error FactoryInvalidFee();
    error FactoryInvalidKinds(uint8 kinds);
    error FactoryInvalidTickSpacing(uint256 tickSpacing);
    error FactoryInvalidLookback(uint256 lookback);
    error FactoryInvalidTokenDecimals(uint8 decimalsA, uint8 decimalsB);
    error FactoryPoolAlreadyExists(
        uint256 feeAIn,
        uint256 feeBIn,
        uint256 tickSpacing,
        uint256 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        uint8 kinds,
        address accessor
    );
    error FactoryAccessorMustBeNonZero();

    event PoolCreated(
        IMaverickV2Pool poolAddress,
        uint8 protocolFeeRatio,
        uint256 feeAIn,
        uint256 feeBIn,
        uint256 tickSpacing,
        uint256 lookback,
        int32 activeTick,
        IERC20 tokenA,
        IERC20 tokenB,
        uint8 kinds,
        address accessor
    );
    event SetFactoryProtocolFeeRatio(uint8 protocolFeeRatioD3);
    event SetFactoryProtocolLendingFeeRate(uint256 lendingFeeRateD18);
    event SetFactoryProtocolFeeReceiver(address receiver);

    struct DeployParameters {
        uint64 feeAIn;
        uint64 feeBIn;
        uint32 lookback;
        int32 activeTick;
        uint64 tokenAScale;
        uint64 tokenBScale;
        // slot
        IERC20 tokenA;
        // slot
        IERC20 tokenB;
        // slot
        uint16 tickSpacing;
        uint8 options;
        address accessor;
    }

    /**
     * @notice Called by deployer library to initialize a pool.
     */
    function deployParameters()
        external
        view
        returns (
            uint64 feeAIn,
            uint64 feeBIn,
            uint32 lookback,
            int32 activeTick,
            uint64 tokenAScale,
            uint64 tokenBScale,
            // slot
            IERC20 tokenA,
            // slot
            IERC20 tokenB,
            // slot
            uint16 tickSpacing,
            uint8 options,
            address accessor
        );

    /**
     * @notice Create a new MaverickV2Pool with symmetric swap fees.
     * @param fee Fraction of the pool swap amount that is retained as an LP in
     * D18 scale.
     * @param tickSpacing Tick spacing of pool where 1.0001^tickSpacing is the
     * bin width.
     * @param lookback Pool lookback in seconds.
     * @param tokenA Address of tokenA.
     * @param tokenB Address of tokenB.
     * @param activeTick Tick position that contains the active bins.
     * @param kinds 1-15 number to represent the active kinds
     * 0b0001 = static;
     * 0b0010 = right;
     * 0b0100 = left;
     * 0b1000 = both.
     * E.g. a pool with all 4 modes will have kinds = b1111 = 15
     */
    function create(
        uint64 fee,
        uint16 tickSpacing,
        uint32 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        int32 activeTick,
        uint8 kinds
    ) external returns (IMaverickV2Pool);

    /**
     * @notice Create a new MaverickV2Pool.
     * @param feeAIn Fraction of the pool swap amount for tokenA-input swaps
     * that is retained as an LP in D18 scale.
     * @param feeBIn Fraction of the pool swap amount for tokenB-input swaps
     * that is retained as an LP in D18 scale.
     * @param tickSpacing Tick spacing of pool where 1.0001^tickSpacing is the
     * bin width.
     * @param lookback Pool lookback in seconds.
     * @param tokenA Address of tokenA.
     * @param tokenB Address of tokenB.
     * @param activeTick Tick position that contains the active bins.
     * @param kinds 1-15 number to represent the active kinds
     * 0b0001 = static;
     * 0b0010 = right;
     * 0b0100 = left;
     * 0b1000 = both.
     * e.g. a pool with all 4 modes will have kinds = b1111 = 15
     */
    function create(
        uint64 feeAIn,
        uint64 feeBIn,
        uint16 tickSpacing,
        uint32 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        int32 activeTick,
        uint8 kinds
    ) external returns (IMaverickV2Pool);

    /**
     * @notice Create a new MaverickV2PoolPermissioned with symmetric swap fees
     * with all functions permissioned.  Set fee to zero to make the pool fee settable by the accessor.
     * @param fee Fraction of the pool swap amount that is retained as an LP in
     * D18 scale.
     * @param tickSpacing Tick spacing of pool where 1.0001^tickSpacing is the
     * bin width.
     * @param lookback Pool lookback in seconds.
     * @param tokenA Address of tokenA.
     * @param tokenB Address of tokenB.
     * @param activeTick Tick position that contains the active bins.
     * @param kinds 1-15 number to represent the active kinds
     * 0b0001 = static;
     * 0b0010 = right;
     * 0b0100 = left;
     * 0b1000 = both.
     * E.g. a pool with all 4 modes will have kinds = b1111 = 15
     * @param accessor Only address that can access the pool's public write functions.
     */
    function createPermissioned(
        uint64 fee,
        uint16 tickSpacing,
        uint32 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        int32 activeTick,
        uint8 kinds,
        address accessor
    ) external returns (IMaverickV2Pool);

    /**
     * @notice Create a new MaverickV2PoolPermissioned with all functions
     * permissioned. Set fees to zero to make the pool fee settable by the
     * accessor.
     * @param feeAIn Fraction of the pool swap amount for tokenA-input swaps
     * that is retained as an LP in D18 scale.
     * @param feeBIn Fraction of the pool swap amount for tokenB-input swaps
     * that is retained as an LP in D18 scale.
     * @param tickSpacing Tick spacing of pool where 1.0001^tickSpacing is the
     * bin width.
     * @param lookback Pool lookback in seconds.
     * @param tokenA Address of tokenA.
     * @param tokenB Address of tokenB.
     * @param activeTick Tick position that contains the active bins.
     * @param kinds 1-15 number to represent the active kinds
     * 0b0001 = static;
     * 0b0010 = right;
     * 0b0100 = left;
     * 0b1000 = both.
     * E.g. a pool with all 4 modes will have kinds = b1111 = 15
     * @param accessor only address that can access the pool's public write functions.
     */
    function createPermissioned(
        uint64 feeAIn,
        uint64 feeBIn,
        uint16 tickSpacing,
        uint32 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        int32 activeTick,
        uint8 kinds,
        address accessor
    ) external returns (IMaverickV2Pool);

    /**
     * @notice Create a new MaverickV2PoolPermissioned with the option to make
     * a subset of function permissionless. Set fee to zero to make the pool
     * fee settable by the accessor.
     * @param feeAIn Fraction of the pool swap amount for tokenA-input swaps
     * that is retained as an LP in D18 scale.
     * @param feeBIn Fraction of the pool swap amount for tokenB-input swaps
     * that is retained as an LP in D18 scale.
     * @param tickSpacing Tick spacing of pool where 1.0001^tickSpacing is the
     * bin width.
     * @param lookback Pool lookback in seconds.
     * @param tokenA Address of tokenA.
     * @param tokenB Address of tokenB.
     * @param activeTick Tick position that contains the active bins.
     * @param kinds 1-15 number to represent the active kinds
     * 0b0001 = static;
     * 0b0010 = right;
     * 0b0100 = left;
     * 0b1000 = both.
     * E.g. a pool with all 4 modes will have kinds = b1111 = 15
     * @param accessor only address that can access the pool's public permissioned write functions.
     * @param  permissionedLiquidity If true, then only accessor can call
     * pool's liquidity management functions: `flashLoan`,
     * `migrateBinsUpstack`, `addLiquidity`, `removeLiquidity`.
     * @param  permissionedSwap If true, then only accessor can call
     * pool's swap function.
     */
    function createPermissioned(
        uint64 feeAIn,
        uint64 feeBIn,
        uint16 tickSpacing,
        uint32 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        int32 activeTick,
        uint8 kinds,
        address accessor,
        bool permissionedLiquidity,
        bool permissionedSwap
    ) external returns (IMaverickV2Pool pool);

    /**
     * @notice Update the protocol fee ratio for a pool. Can be called
     * permissionlessly allowing any user to sync the pool protocol fee value
     * with the factory protocol fee value.
     * @param pool The pool for which to update.
     */
    function updateProtocolFeeRatioForPool(IMaverickV2Pool pool) external;

    /**
     * @notice Update the protocol lending fee rate for a pool. Can be called
     * permissionlessly allowing any user to sync the pool protocol lending fee
     * rate value with the factory value.
     * @param pool The pool for which to update.
     */
    function updateProtocolLendingFeeRateForPool(IMaverickV2Pool pool) external;

    /**
     * @notice Claim protocol fee for a pool and transfer it to the protocolFeeReceiver.
     * @param pool The pool from which to claim the protocol fee.
     * @param isTokenA A boolean indicating whether tokenA (true) or tokenB
     * (false) is being collected.
     */
    function claimProtocolFeeForPool(IMaverickV2Pool pool, bool isTokenA) external;

    /**
     * @notice Claim protocol fee for a pool and transfer it to the protocolFeeReceiver.
     * @param pool The pool from which to claim the protocol fee.
     */
    function claimProtocolFeeForPool(IMaverickV2Pool pool) external;

    /**
     * @notice Bool indicating whether the pool was deployed from this factory.
     */
    function isFactoryPool(IMaverickV2Pool pool) external view returns (bool);

    /**
     * @notice Address that receives the protocol fee when users call
     * `claimProtocolFeeForPool`.
     */
    function protocolFeeReceiver() external view returns (address);

    /**
     * @notice Lookup a pool for given parameters.
     *
     * @dev  options bit map of kinds and function permissions
     * 0b000001 = static;
     * 0b000010 = right;
     * 0b000100 = left;
     * 0b001000 = both;
     * 0b010000 = liquidity functions are permissioned
     * 0b100000 = swap function is permissioned
     */
    function lookupPermissioned(
        uint256 feeAIn,
        uint256 feeBIn,
        uint256 tickSpacing,
        uint256 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        uint8 options,
        address accessor
    ) external view returns (IMaverickV2Pool);

    /**
     * @notice Lookup a pool for given parameters.
     */
    function lookupPermissioned(
        IERC20 _tokenA,
        IERC20 _tokenB,
        address accessor,
        uint256 startIndex,
        uint256 endIndex
    ) external view returns (IMaverickV2Pool[] memory pools);

    /**
     * @notice Lookup a pool for given parameters.
     */
    function lookupPermissioned(
        uint256 startIndex,
        uint256 endIndex
    ) external view returns (IMaverickV2Pool[] memory pools);

    /**
     * @notice Lookup a pool for given parameters.
     */
    function lookup(
        uint256 feeAIn,
        uint256 feeBIn,
        uint256 tickSpacing,
        uint256 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        uint8 kinds
    ) external view returns (IMaverickV2Pool);

    /**
     * @notice Lookup a pool for given parameters.
     */
    function lookup(
        IERC20 _tokenA,
        IERC20 _tokenB,
        uint256 startIndex,
        uint256 endIndex
    ) external view returns (IMaverickV2Pool[] memory pools);

    /**
     * @notice Lookup a pool for given parameters.
     */
    function lookup(uint256 startIndex, uint256 endIndex) external view returns (IMaverickV2Pool[] memory pools);

    /**
     * @notice Count of permissionless pools.
     */
    function poolCount() external view returns (uint256 _poolCount);

    /**
     * @notice Count of permissioned pools.
     */
    function poolPermissionedCount() external view returns (uint256 _poolCount);

    /**
     * @notice Count of pools for a given accessor and token pair.  For
     * permissionless pools, pass `accessor = address(0)`.
     */
    function poolByTokenCount(
        IERC20 _tokenA,
        IERC20 _tokenB,
        address accessor
    ) external view returns (uint256 _poolCount);

    /**
     * @notice Get the current factory owner.
     */
    function owner() external view returns (address);

    /**
     * @notice Proportion of protocol fee to collect on each swap.  Value is in
     * 3-decimal format with a maximum value of 0.25e3.
     */
    function protocolFeeRatioD3() external view returns (uint8);

    /**
     * @notice Fee rate charged by the protocol for flashloans.  Value is in
     * 18-decimal format with a maximum value of 0.02e18.
     */
    function protocolLendingFeeRateD18() external view returns (uint256);
}

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

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

import {IMaverickV2Pool} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Pool.sol";

import {IMaverickV2Position} from "./IMaverickV2Position.sol";
import {IMaverickV2BoostedPosition} from "./IMaverickV2BoostedPosition.sol";
import {IMaverickV2PoolLens} from "./IMaverickV2PoolLens.sol";
import {IMaverickV2BoostedPositionFactory} from "./IMaverickV2BoostedPositionFactory.sol";
import {IArgPacker} from "../liquiditybase/IArgPacker.sol";
import {IExactOutputSlim} from "../routerbase/IExactOutputSlim.sol";
import {IPayment} from "../paymentbase/IPayment.sol";
import {IChecks} from "../base/IChecks.sol";
import {IMigrateBins} from "../base/IMigrateBins.sol";

interface IMaverickV2LiquidityManager is IPayment, IChecks, IExactOutputSlim, IArgPacker, IMigrateBins {
    error LiquidityManagerNotFactoryPool();
    error LiquidityManagerNotTokenIdOwner();

    /**
     * @notice Maverick V2 NFT position contract that tracks NFT-based
     * liquditiy positions.
     */
    function position() external view returns (IMaverickV2Position);

    /**
     * @notice Maverick V2 BP factory contract.
     */
    function boostedPositionFactory() external view returns (IMaverickV2BoostedPositionFactory);

    /**
     * @notice Create Maverick V2 pool.  Function is a pass through to the pool
     * factory and is provided here so that is can be assembled as part of a
     * multicall transaction.
     */
    function createPool(
        uint64 fee,
        uint16 tickSpacing,
        uint32 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        int32 activeTick,
        uint8 kinds
    ) external payable returns (IMaverickV2Pool pool);

    /**
     * @notice Create Maverick V2 pool with two-way fees.  Function is a pass
     * through to the pool factory and is provided here so that is can be
     * assembled as part of a multicall transaction.
     */
    function createPool(
        uint64 feeAIn,
        uint64 feeBIn,
        uint16 tickSpacing,
        uint32 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        int32 activeTick,
        uint8 kinds
    ) external payable returns (IMaverickV2Pool pool);

    /**
     * @notice Add Liquidity to a Maverick V2 pool.  Function is a pass through
     * to the pool and is provided here so that is can be assembled as part of a
     * multicall transaction.  Users can add liquidity to the Position NFT
     * contract or a BP as part of a multicall in order to mint NFT/BP
     * positions.
     * @dev Liquidity is specified as bytes that represent a lookup table of
     * add parameters.  This allows an adder to specify what liquidity amounts
     * they wish to add conditional on the price of the pool when their
     * transaction is executed.  With this, users have fine-grain control of how
     * price slippage affects the amount of liquidity they add.  The
     * MaverickV2PoolLens contract has helper view functions that can be used
     * to easily create a combination of price breaks and packed arguments.
     */
    function addLiquidity(
        IMaverickV2Pool pool,
        address recipient,
        uint256 subaccount,
        bytes calldata packedSqrtPriceBreaks,
        bytes[] calldata packedArgs
    ) external payable returns (uint256 tokenAAmount, uint256 tokenBAmount, uint32[] memory binIds);

    /**
     * @notice Add Liquidity position NFT for msg.sender by specifying
     * msg.sender's token index.
     * @dev Token index is different from tokenId.
     * On the Position NFT contract a user can own multiple NFT tokenIds and
     * these are indexes by an enumeration index which is the `index` input
     * here.
     *
     * See addLiquidity for a description of the add params.
     */
    function addPositionLiquidityToSenderByTokenIndex(
        IMaverickV2Pool pool,
        uint256 index,
        bytes memory packedSqrtPriceBreaks,
        bytes[] memory packedArgs
    ) external payable returns (uint256 tokenAAmount, uint256 tokenBAmount, uint32[] memory binIds);

    /**
     * @notice Add Liquidity position NFT for msg.sender by specifying
     * recipient's token index.
     * @dev Token index is different from tokenId.
     * On the Position NFT contract a user can own multiple NFT tokenIds and
     * these are indexes by an enumeration index which is the `index` input
     * here.
     *
     * See addLiquidity for a description of the add params.
     */
    function addPositionLiquidityToRecipientByTokenIndex(
        IMaverickV2Pool pool,
        address recipient,
        uint256 index,
        bytes memory packedSqrtPriceBreaks,
        bytes[] memory packedArgs
    ) external payable returns (uint256 tokenAAmount, uint256 tokenBAmount, uint32[] memory binIds);

    /**
     * @notice Pass through function to the BP bin migration.
     */
    function migrateBoostedPosition(IMaverickV2BoostedPosition boostedPosition) external payable;

    /**
     * @notice Mint new tokenId in the Position NFT contract. Both mints an NFT
     * and adds liquidity to the pool that is held by the NFT.
     * @dev Caller must approve this LiquidityManager contract to spend the
     * caller's token A/B in order to fund the liquidity position.
     *
     * See addLiquidity for a description of the add params.
     */
    function mintPositionNft(
        IMaverickV2Pool pool,
        address recipient,
        bytes calldata packedSqrtPriceBreaks,
        bytes[] calldata packedArgs
    ) external payable returns (uint256 tokenAAmount, uint256 tokenBAmount, uint32[] memory binIds, uint256 tokenId);

    /**
     * @notice Mint new tokenId in the Position NFt contract to msg.sender.
     * Both mints an NFT and adds liquidity to the pool that is held by the
     * NFT.
     */
    function mintPositionNftToSender(
        IMaverickV2Pool pool,
        bytes calldata packedSqrtPriceBreaks,
        bytes[] calldata packedArgs
    ) external payable returns (uint256 tokenAAmount, uint256 tokenBAmount, uint32[] memory binIds, uint256 tokenId);

    /**
     * @notice Mint BP LP tokens to recipient.  This function does not add
     * liquidity to the BP and is only useful in conjuction with addLiquidity
     * as part of a multcall.
     */
    function mintBoostedPosition(
        IMaverickV2BoostedPosition boostedPosition,
        address recipient
    ) external payable returns (uint256 mintedLpAmount);

    /**
     * @notice Donates liqudity to a pool that is held by the position contract
     * and will never be retrievable.  Can be used to start a pool and ensure
     * there will always be a base level of liquditiy in the pool.
     */
    function donateLiquidity(IMaverickV2Pool pool, IMaverickV2Pool.AddLiquidityParams memory args) external payable;

    /**
     * @notice Creates a pool at a specified price and mints a Position NFT
     * with liquidity to the recipient.
     * @dev A Maverick V2 pool has no native was to specify a starting price,
     * only a starting `activeTick`.  The initial pool price will be the left
     * edge of the initial activeTick.  In order to create a pool at a fixed
     * price, this function dontes a small amount of liquidity to the pool, does
     * a swap to the specified price, and then adds liquidity for the user.
     */
    function createPoolAtPriceAndAddLiquidity(
        address recipient,
        IMaverickV2PoolLens.CreateAndAddParamsInputs memory params
    )
        external
        payable
        returns (
            IMaverickV2Pool pool,
            uint256 tokenAAmount,
            uint256 tokenBAmount,
            uint32[] memory binIds,
            uint256 tokenId
        );

    /**
     * @notice Creates a pool at a specified price and mints a Position NFT
     * with liquidity to msg.sender.
     */
    function createPoolAtPriceAndAddLiquidityToSender(
        IMaverickV2PoolLens.CreateAndAddParamsInputs memory params
    )
        external
        payable
        returns (
            IMaverickV2Pool pool,
            uint256 tokenAAmount,
            uint256 tokenBAmount,
            uint32[] memory binIds,
            uint256 tokenId
        );

    /**
     * @notice Executes the multi-step process of minting BP LP positions by
     * adding liqudiity to a pool in the BP liquidity distribution and then
     * minting the BP to recipient.
     * @dev Caller will need to approve this LiquidityManager contract to spend
     * their token A/B in order to execute this function.
     */
    function addLiquidityAndMintBoostedPosition(
        address recipient,
        IMaverickV2BoostedPosition boostedPosition,
        bytes memory packedSqrtPriceBreaks,
        bytes[] memory packedArgs
    ) external payable returns (uint256 mintedLpAmount, uint256 tokenAAmount, uint256 tokenBAmount);

    /**
     * @notice Executes the multi-step process of minting BP LP positions by
     * adding liquidity to a pool in the BP liquidity distribution and then
     * minting the BP to msg.sender.
     * @dev Caller will need to approve this LiquidityManager contract to spend
     * their token A/B in order to execute this function.
     */
    function addLiquidityAndMintBoostedPositionToSender(
        IMaverickV2BoostedPosition boostedPosition,
        bytes memory packedSqrtPriceBreaks,
        bytes[] memory packedArgs
    ) external payable returns (uint256 mintedLpAmount, uint256 tokenAAmount, uint256 tokenBAmount);

    /**
     * @notice Deploy new BP contract from the BP factory and mint BP LP tokens
     * to the recipient.
     * @dev Caller will need to approve this LiquidityManager contract to spend
     * their token A/B in order to execute this function.
     */
    function createBoostedPositionAndAddLiquidity(
        address recipient,
        IMaverickV2PoolLens.CreateBoostedPositionInputs memory params
    )
        external
        payable
        returns (
            IMaverickV2BoostedPosition boostedPosition,
            uint256 mintedLpAmount,
            uint256 tokenAAmount,
            uint256 tokenBAmount
        );

    /**
     * @notice Deploy new BP contract from the BP factory and mint BP LP tokens
     * to msg.sender.
     * @dev Caller will need to approve this LiquidityManager contract to spend
     * their token A/B in order to execute this function.
     */
    function createBoostedPositionAndAddLiquidityToSender(
        IMaverickV2PoolLens.CreateBoostedPositionInputs memory params
    )
        external
        payable
        returns (
            IMaverickV2BoostedPosition boostedPosition,
            uint256 mintedLpAmount,
            uint256 tokenAAmount,
            uint256 tokenBAmount
        );

    /**
     * @notice Skims excess liquidity in a BP to the recipient.
     */
    function skimBoostedPosition(
        IMaverickV2BoostedPosition boostedPosition,
        address recipient
    ) external payable returns (uint256 tokenAAmount, uint256 tokenBAmount);
}

// SPDX-License-Identifier: GPL-2.0-or-later
// As the copyright holder of this work, Ubiquity Labs retains
// the right to distribute, use, and modify this code under any license of
// their choosing, in addition to the terms of the GPL-v2 or later.
pragma solidity ^0.8.25;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IMaverickV2Factory} from "./IMaverickV2Factory.sol";

interface IMaverickV2Pool {
    error PoolZeroLiquidityAdded();
    error PoolMinimumLiquidityNotMet();
    error PoolLocked();
    error PoolInvalidFee();
    error PoolTicksNotSorted(uint256 index, int256 previousTick, int256 tick);
    error PoolTicksAmountsLengthMismatch(uint256 ticksLength, uint256 amountsLength);
    error PoolBinIdsAmountsLengthMismatch(uint256 binIdsLength, uint256 amountsLength);
    error PoolKindNotSupported(uint256 kinds, uint256 kind);
    error PoolInsufficientBalance(uint256 deltaLpAmount, uint256 accountBalance);
    error PoolReservesExceedMaximum(uint256 amount);
    error PoolValueExceedsBits(uint256 amount, uint256 bits);
    error PoolTickMaxExceeded(uint256 tick);
    error PoolMigrateBinFirst();
    error PoolCurrentTickBeyondSwapLimit(int32 startingTick);
    error PoolSenderNotAccessor(address sender_, address accessor);
    error PoolSenderNotFactory(address sender_, address accessor);
    error PoolFunctionNotImplemented();
    error PoolTokenNotSolvent(uint256 internalReserve, uint256 tokenBalance, IERC20 token);

    event PoolSwap(address sender, address recipient, SwapParams params, uint256 amountIn, uint256 amountOut);

    event PoolAddLiquidity(
        address sender,
        address recipient,
        uint256 subaccount,
        AddLiquidityParams params,
        uint256 tokenAAmount,
        uint256 tokenBAmount,
        uint32[] binIds
    );

    event PoolMigrateBinsUpStack(address sender, uint32 binId, uint32 maxRecursion);

    event PoolRemoveLiquidity(
        address sender,
        address recipient,
        uint256 subaccount,
        RemoveLiquidityParams params,
        uint256 tokenAOut,
        uint256 tokenBOut
    );

    event PoolSetVariableFee(uint256 newFeeAIn, uint256 newFeeBIn);

    /**
     * @notice Tick state parameters.
     */
    struct TickState {
        uint128 reserveA;
        uint128 reserveB;
        uint128 totalSupply;
        uint32[4] binIdsByTick;
    }

    /**
     * @notice Tick data parameters.
     * @param currentReserveA Current reserve of token A.
     * @param currentReserveB Current reserve of token B.
     * @param currentLiquidity Current liquidity amount.
     */
    struct TickData {
        uint256 currentReserveA;
        uint256 currentReserveB;
        uint256 currentLiquidity;
    }

    /**
     * @notice Bin state parameters.
     * @param mergeBinBalance LP token balance that this bin possesses of the merge bin.
     * @param mergeId Bin ID of the bin that this bin has merged into.
     * @param totalSupply Total amount of LP tokens in this bin.
     * @param kind One of the 4 kinds (0=static, 1=right, 2=left, 3=both).
     * @param tick The lower price tick of the bin in its current state.
     * @param tickBalance Balance of the tick.
     */
    struct BinState {
        uint128 mergeBinBalance;
        uint128 tickBalance;
        uint128 totalSupply;
        uint8 kind;
        int32 tick;
        uint32 mergeId;
    }

    /**
     * @notice Parameters for swap.
     * @param amount Amount of the token that is either the input if exactOutput is false
     * or the output if exactOutput is true.
     * @param tokenAIn Boolean indicating whether tokenA is the input.
     * @param exactOutput Boolean indicating whether the amount specified is
     * the exact output amount (true).
     * @param tickLimit The furthest tick a swap will execute in. If no limit
     * is desired, value should be set to type(int32).max for a tokenAIn swap
     * and type(int32).min for a swap where tokenB is the input.
     */
    struct SwapParams {
        uint256 amount;
        bool tokenAIn;
        bool exactOutput;
        int32 tickLimit;
    }

    /**
     * @notice Parameters associated with adding liquidity.
     * @param kind One of the 4 kinds (0=static, 1=right, 2=left, 3=both).
     * @param ticks Array of ticks to add liquidity to.
     * @param amounts Array of bin LP amounts to add.
     */
    struct AddLiquidityParams {
        uint8 kind;
        int32[] ticks;
        uint128[] amounts;
    }

    /**
     * @notice Parameters for each bin that will have liquidity removed.
     * @param binIds Index array of the bins losing liquidity.
     * @param amounts Array of bin LP amounts to remove.
     */
    struct RemoveLiquidityParams {
        uint32[] binIds;
        uint128[] amounts;
    }

    /**
     * @notice State of the pool.
     * @param reserveA Pool tokenA balanceOf at end of last operation
     * @param reserveB Pool tokenB balanceOf at end of last operation
     * @param lastTwaD8 Value of log time weighted average price at last block.
     * Value is 8-decimal scale and is in the fractional tick domain.  E.g. a
     * value of 12.3e8 indicates the TWAP was 3/10ths of the way into the 12th
     * tick.
     * @param lastLogPriceD8 Value of log price at last block. Value is
     * 8-decimal scale and is in the fractional tick domain.  E.g. a value of
     * 12.3e8 indicates the price was 3/10ths of the way into the 12th tick.
     * @param lastTimestamp Last block.timestamp value in seconds for latest
     * swap transaction.
     * @param activeTick Current tick position that contains the active bins.
     * @param isLocked Pool isLocked, E.g., locked or unlocked; isLocked values
     * defined in Pool.sol.
     * @param binCounter Index of the last bin created.
     * @param protocolFeeRatioD3 Ratio of the swap fee that is kept for the
     * protocol.
     */
    struct State {
        uint128 reserveA;
        uint128 reserveB;
        int64 lastTwaD8;
        int64 lastLogPriceD8;
        uint40 lastTimestamp;
        int32 activeTick;
        bool isLocked;
        uint32 binCounter;
        uint8 protocolFeeRatioD3;
    }

    /**
     * @notice Internal data used for data passing between Pool and Bin code.
     */
    struct BinDelta {
        uint128 deltaA;
        uint128 deltaB;
    }

    /**
     * @notice 1-15 number to represent the active kinds.
     * @notice 0b0001 = static;
     * @notice 0b0010 = right;
     * @notice 0b0100 = left;
     * @notice 0b1000 = both;
     *
     * E.g. a pool with all 4 modes will have kinds = b1111 = 15
     */
    function kinds() external view returns (uint8 _kinds);

    /**
     * @notice Returns whether a pool has permissioned functions. If true, the
     * `accessor()` of the pool can set the pool fees.  Other functions in the
     * pool may also be permissioned; whether or not they are can be determined
     * through calls to `permissionedLiquidity()` and `permissionedSwap()`.
     */
    function permissionedPool() external view returns (bool _permissionedPool);

    /**
     * @notice Returns whether a pool has permissioned liquidity management
     * functions. If true, the pool is incompatible with permissioned pool
     * liquidity management infrastructure.
     */
    function permissionedLiquidity() external view returns (bool _permissionedLiquidity);

    /**
     * @notice Returns whether a pool has a permissioned swap functions. If
     * true, the pool is incompatible with permissioned pool swap router
     * infrastructure.
     */
    function permissionedSwap() external view returns (bool _permissionedSwap);

    /**
     * @notice Pool swap fee for the given direction (A-in or B-in swap) in
     * 18-decimal format. E.g. 0.01e18 is a 1% swap fee.
     */
    function fee(bool tokenAIn) external view returns (uint256);

    /**
     * @notice TickSpacing of pool where 1.0001^tickSpacing is the bin width.
     */
    function tickSpacing() external view returns (uint256);

    /**
     * @notice Lookback period of pool in seconds.
     */
    function lookback() external view returns (uint256);

    /**
     * @notice Address of Pool accessor.  This is Zero address for
     * permissionless pools.
     */
    function accessor() external view returns (address);

    /**
     * @notice Pool tokenA.  Address of tokenA is such that tokenA < tokenB.
     */
    function tokenA() external view returns (IERC20);

    /**
     * @notice Pool tokenB.
     */
    function tokenB() external view returns (IERC20);

    /**
     * @notice Deploying factory of the pool and also contract that has ability
     * to set and collect protocol fees for the pool.
     */
    function factory() external view returns (IMaverickV2Factory);

    /**
     * @notice Most significant bit of scale value is a flag to indicate whether
     * tokenA has more or less than 18 decimals.  Scale is used in conjuction
     * with Math.toScale/Math.fromScale functions to convert from token amounts
     * to D18 scale internal pool accounting.
     */
    function tokenAScale() external view returns (uint256);

    /**
     * @notice Most significant bit of scale value is a flag to indicate whether
     * tokenA has more or less than 18 decimals.  Scale is used in conjuction
     * with Math.toScale/Math.fromScale functions to convert from token amounts
     * to D18 scale internal pool accounting.
     */
    function tokenBScale() external view returns (uint256);

    /**
     * @notice ID of bin at input tick position and kind.
     */
    function binIdByTickKind(int32 tick, uint256 kind) external view returns (uint32);

    /**
     * @notice Accumulated tokenA protocol fee.
     */
    function protocolFeeA() external view returns (uint128);

    /**
     * @notice Accumulated tokenB protocol fee.
     */
    function protocolFeeB() external view returns (uint128);

    /**
     * @notice Lending fee rate on flash loans.
     */
    function lendingFeeRateD18() external view returns (uint256);

    /**
     * @notice External function to get the current time-weighted average price.
     */
    function getCurrentTwa() external view returns (int256);

    /**
     * @notice External function to get the state of the pool.
     */
    function getState() external view returns (State memory);

    /**
     * @notice Return state of Bin at input binId.
     */
    function getBin(uint32 binId) external view returns (BinState memory bin);

    /**
     * @notice Return state of Tick at input tick position.
     */
    function getTick(int32 tick) external view returns (TickState memory tickState);

    /**
     * @notice Retrieves the balance of a user within a bin.
     * @param user The user's address.
     * @param subaccount The subaccount for the user.
     * @param binId The ID of the bin.
     */
    function balanceOf(address user, uint256 subaccount, uint32 binId) external view returns (uint128 lpToken);

    /**
     * @notice Add liquidity to a pool. This function allows users to deposit
     * tokens into a liquidity pool.
     * @dev This function will call `maverickV2AddLiquidityCallback` on the
     * calling contract to collect the tokenA/tokenB payment.
     * @param recipient The account that will receive credit for the added liquidity.
     * @param subaccount The account that will receive credit for the added liquidity.
     * @param params Parameters containing the details for adding liquidity,
     * such as token types and amounts.
     * @param data Bytes information that gets passed to the callback.
     * @return tokenAAmount The amount of token A added to the pool.
     * @return tokenBAmount The amount of token B added to the pool.
     * @return binIds An array of bin IDs where the liquidity is stored.
     */
    function addLiquidity(
        address recipient,
        uint256 subaccount,
        AddLiquidityParams calldata params,
        bytes calldata data
    ) external returns (uint256 tokenAAmount, uint256 tokenBAmount, uint32[] memory binIds);

    /**
     * @notice Removes liquidity from the pool.
     * @dev Liquidy can only be removed from a bin that is either unmerged or
     * has a mergeId of an unmerged bin.  If a bin is merged more than one
     * level deep, it must be migrated up the merge stack to the root bin
     * before liquidity removal.
     * @param recipient The address to receive the tokens.
     * @param subaccount The subaccount for the recipient.
     * @param params The parameters for removing liquidity.
     * @return tokenAOut The amount of token A received.
     * @return tokenBOut The amount of token B received.
     */
    function removeLiquidity(
        address recipient,
        uint256 subaccount,
        RemoveLiquidityParams calldata params
    ) external returns (uint256 tokenAOut, uint256 tokenBOut);

    /**
     * @notice Migrate bins up the linked list of merged bins so that its
     * mergeId is the currrent active bin.
     * @dev Liquidy can only be removed from a bin that is either unmerged or
     * has a mergeId of an unmerged bin.  If a bin is merged more than one
     * level deep, it must be migrated up the merge stack to the root bin
     * before liquidity removal.
     * @param binId The ID of the bin to migrate.
     * @param maxRecursion The maximum recursion depth for the migration.
     */
    function migrateBinUpStack(uint32 binId, uint32 maxRecursion) external;

    /**
     * @notice Swap tokenA/tokenB assets in the pool.  The swap user has two
     * options for funding their swap.
     * - The user can push the input token amount to the pool before calling
     * the swap function. In order to avoid having the pool call the callback,
     * the user should pass a zero-length `data` bytes object with the swap
     * call.
     * - The user can send the input token amount to the pool when the pool
     * calls the `maverickV2SwapCallback` function on the calling contract.
     * That callback has input parameters that specify the token address of the
     * input token, the input and output amounts, and the bytes data sent to
     * the swap function.
     * @dev  If the users elects to do a callback-based swap, the output
     * assets will be sent before the callback is called, allowing the user to
     * execute flash swaps.  However, the pool does have reentrancy protection,
     * so a swapper will not be able to interact with the same pool again
     * while they are in the callback function.
     * @param recipient The address to receive the output tokens.
     * @param params Parameters containing the details of the swap
     * @param data Bytes information that gets passed to the callback.
     */
    function swap(
        address recipient,
        SwapParams memory params,
        bytes calldata data
    ) external returns (uint256 amountIn, uint256 amountOut);

    /**
     * @notice Loan tokenA/tokenB assets from the pool to recipient. The fee
     * rate of a loan is determined by `lendingFeeRateD18`, which is set at the
     * protocol level by the factory.  This function calls
     * `maverickV2FlashLoanCallback` on the calling contract.  At the end of
     * the callback, the caller must pay back the loan with fee (if there is a
     * fee).
     * @param recipient The address to receive the loaned tokens.
     * @param amountB Loan amount of tokenA sent to recipient.
     * @param amountB Loan amount of tokenB sent to recipient.
     * @param data Bytes information that gets passed to the callback.
     */
    function flashLoan(
        address recipient,
        uint256 amountA,
        uint256 amountB,
        bytes calldata data
    ) external returns (uint128 lendingFeeA, uint128 lendingFeeB);

    /**
     * @notice Sets fee for permissioned pools.  May only be called by the
     * accessor.
     */
    function setFee(uint256 newFeeAIn, uint256 newFeeBIn) external;
}

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

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IMaverickV2Factory} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Factory.sol";
import {IMaverickV2Pool} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Pool.sol";
import {IMaverickV2BoostedPosition} from "./IMaverickV2BoostedPosition.sol";

interface IMaverickV2PoolLens {
    error LensTargetPriceOutOfBounds(uint256 targetSqrtPrice, uint256 sqrtLowerTickPrice, uint256 sqrtUpperTickPrice);
    error LensTooLittleLiquidity(uint256 relativeLiquidityAmount, uint256 deltaA, uint256 deltaB);
    error LensTargetingTokenWithNoDelta(bool targetIsA, uint256 deltaA, uint256 deltaB);

    /**
     * @notice Add liquidity slippage parameters for a distribution of liquidity.
     * @param pool Pool where liquidity is being added.
     * @param kind Bin kind; all bins must have the same kind in a given call
     * to addLiquidity.
     * @param ticks Array of tick values to add liquidity to.
     * @param relativeLiquidityAmounts Relative liquidity amounts for the
     * specified ticks.  Liquidity in this case is not bin LP balance, it is
     * the bin liquidity as defined by liquidity = deltaA / (sqrt(upper) -
     * sqrt(lower)) or deltaB = liquidity / sqrt(lower) - liquidity /
     * sqrt(upper).
     * @param addSpec Slippage specification.
     */
    struct AddParamsViewInputs {
        IMaverickV2Pool pool;
        uint8 kind;
        int32[] ticks;
        uint128[] relativeLiquidityAmounts;
        AddParamsSpecification addSpec;
    }

    /**
     * @notice Multi-price add param specification.
     * @param slippageFactorD18 Max slippage allowed as a percent in D18 scale. e.g. 1% slippage is 0.01e18
     * @param numberOfPriceBreaksPerSide Number of price break values on either
     * side of current price.
     * @param targetAmount Target token contribution amount in tokenA if
     * targetIsA is true, otherwise this is the target amount for tokenB.
     * @param targetIsA  Indicates if the target amount is for tokenA or tokenB
     */
    struct AddParamsSpecification {
        uint256 slippageFactorD18;
        uint256 numberOfPriceBreaksPerSide;
        uint256 targetAmount;
        bool targetIsA;
    }

    /**
     * @notice Boosted position creation specification and add parameters.
     * @param bpSpec Boosted position kind/binId/ratio information.
     * @param packedSqrtPriceBreaks Array of sqrt price breaks packed into
     * bytes.  These breaks act as a lookup table for the packedArgs array to
     * indicate to the Liquidity manager what add liquidity parameters from
     * packedArgs to use depending on the price of the pool at add time.
     * @param packedArgs Array of bytes arguments.  Each array element is a
     * packed version of addLiquidity paramters.
     */
    struct CreateBoostedPositionInputs {
        BoostedPositionSpecification bpSpec;
        bytes packedSqrtPriceBreaks;
        bytes[] packedArgs;
    }

    /**
     * @notice Specification for deriving create pool parameters. Creating a pool in the liquidity manager has several steps:
     *
     * - Deploy pool
     * - Donate a small amount of initial liquidity in the activeTick
     * - Execute a small swap to set the pool price to the desired value
     * - Add liquidity
     *
     * In order to execute these steps, the caller must specify the parameters
     * of each step.  The PoolLens has helper function to derive the values
     * used by the LiquidityManager, but this struct is the input to that
     * helper function and represents the core intent of the pool creator.
     *
     * @param fee Fraction of the pool swap amount that is retained as an LP in
     * D18 scale.
     * @param tickSpacing Tick spacing of pool where 1.0001^tickSpacing is the
     * bin width.
     * @param lookback Pool lookback in seconds.
     * @param tokenA Address of tokenA.
     * @param tokenB Address of tokenB.
     * @param activeTick Tick position that contains the active bins.
     * @param kinds 1-15 number to represent the active kinds
     * 0b0001 = static;
     * 0b0010 = right;
     * 0b0100 = left;
     * 0b1000 = both.
     * e.g. a pool with all 4 modes will have kinds = b1111 = 15
     * @param initialTargetB Amount of B to be donated to the pool after pool
     * create.  This amount needs to be big enough to meet the minimum bin
     * liquidity.
     * @param sqrtPrice Target sqrt price of the pool.
     * @param kind Bin kind; all bins must have the same kind in a given call
     * to addLiquidity.
     * @param ticks Array of tick values to add liquidity to.
     * @param relativeLiquidityAmounts Relative liquidity amounts for the
     * specified ticks.  Liquidity in this case is not bin LP balance, it is
     * the bin liquidity as defined by liquidity = deltaA / (sqrt(upper) -
     * sqrt(lower)) or deltaB = liquidity / sqrt(lower) - liquidity /
     * sqrt(upper).
     * @param targetAmount Target token contribution amount in tokenA if
     * targetIsA is true, otherwise this is the target amount for tokenB.
     * @param targetIsA  Indicates if the target amount is for tokenA or tokenB
     */
    struct CreateAndAddParamsViewInputs {
        uint64 feeAIn;
        uint64 feeBIn;
        uint16 tickSpacing;
        uint32 lookback;
        IERC20 tokenA;
        IERC20 tokenB;
        int32 activeTick;
        uint8 kinds;
        // donate params
        uint256 initialTargetB;
        uint256 sqrtPrice;
        // add target
        uint8 kind;
        int32[] ticks;
        uint128[] relativeLiquidityAmounts;
        uint256 targetAmount;
        bool targetIsA;
    }

    struct Output {
        uint256 deltaAOut;
        uint256 deltaBOut;
        uint256[] deltaAs;
        uint256[] deltaBs;
        uint128[] deltaLpBalances;
    }

    struct Reserves {
        uint256 amountA;
        uint256 amountB;
    }

    struct BinPositionKinds {
        uint128[4] values;
    }

    struct PoolState {
        IMaverickV2Pool.TickState[] tickStateMapping;
        IMaverickV2Pool.BinState[] binStateMapping;
        BinPositionKinds[] binIdByTickKindMapping;
        IMaverickV2Pool.State state;
        Reserves protocolFees;
    }

    struct BoostedPositionSpecification {
        IMaverickV2Pool pool;
        uint32[] binIds;
        uint128[] ratios;
        uint8 kind;
    }

    struct CreateAndAddParamsInputs {
        uint64 feeAIn;
        uint64 feeBIn;
        uint16 tickSpacing;
        uint32 lookback;
        IERC20 tokenA;
        IERC20 tokenB;
        int32 activeTick;
        uint8 kinds;
        // donate params
        IMaverickV2Pool.AddLiquidityParams donateParams;
        // swap params
        uint256 swapAmount;
        // add params
        IMaverickV2Pool.AddLiquidityParams addParams;
        bytes[] packedAddParams;
        uint256 deltaAOut;
        uint256 deltaBOut;
        uint256 preAddReserveA;
        uint256 preAddReserveB;
    }

    struct TickDeltas {
        uint256 deltaAOut;
        uint256 deltaBOut;
        uint256[] deltaAs;
        uint256[] deltaBs;
    }

    /**
     * @notice Converts add parameter slippage specification into add
     * parameters.  The return values are given in both raw format and as packed
     * values that can be used in the LiquidityManager contract.
     */
    function getAddLiquidityParams(
        AddParamsViewInputs memory params
    )
        external
        view
        returns (
            bytes memory packedSqrtPriceBreaks,
            bytes[] memory packedArgs,
            uint88[] memory sqrtPriceBreaks,
            IMaverickV2Pool.AddLiquidityParams[] memory addParams,
            IMaverickV2PoolLens.TickDeltas[] memory tickDeltas
        );

    /**
     * @notice Converts add parameter slippage specification for a boosted
     * position into add parameters.  The return values are given in both raw
     * format and as packed values that can be used in the LiquidityManager
     * contract.
     */
    function getAddLiquidityParamsForBoostedPosition(
        IMaverickV2BoostedPosition boostedPosition,
        AddParamsSpecification memory addSpec
    )
        external
        view
        returns (
            bytes memory packedSqrtPriceBreaks,
            bytes[] memory packedArgs,
            uint88[] memory sqrtPriceBreaks,
            IMaverickV2Pool.AddLiquidityParams[] memory addParams,
            IMaverickV2PoolLens.TickDeltas[] memory tickDeltas
        );

    /**
     * @notice Converts add parameter slippage specification and boosted
     * position specification into add parameters.  The return values are given
     * in both raw format and as packed values that can be used in the
     * LiquidityManager contract.
     */
    function getCreateBoostedPositionParams(
        BoostedPositionSpecification memory bpSpec,
        AddParamsSpecification memory addSpec
    )
        external
        view
        returns (
            bytes memory packedSqrtPriceBreaks,
            bytes[] memory packedArgs,
            uint88[] memory sqrtPriceBreaks,
            IMaverickV2Pool.AddLiquidityParams[] memory addParams,
            IMaverickV2PoolLens.TickDeltas[] memory tickDeltas
        );

    /**
     * @notice Converts add parameter slippage specification and new pool
     * specification into CreateAndAddParamsInputs parameters that can be used in the
     * LiquidityManager contract.
     */
    function getCreatePoolAtPriceAndAddLiquidityParams(
        CreateAndAddParamsViewInputs memory params,
        IMaverickV2Factory factory
    ) external view returns (CreateAndAddParamsInputs memory output);

    /**
     * @notice View function that provides information about pool ticks within
     * a tick radius from the activeTick. Ticks with no reserves are not
     * included in part o f the return array.
     */
    function getTicksAroundActive(
        IMaverickV2Pool pool,
        int32 tickRadius
    ) external view returns (int32[] memory ticks, IMaverickV2Pool.TickState[] memory tickStates);

    /**
     * @notice View function that provides information about pool ticks within
     * a range. Ticks with no reserves are not included in part o f the return
     * array.
     */
    function getTicks(
        IMaverickV2Pool pool,
        int32 tickStart,
        int32 tickEnd
    ) external view returns (int32[] memory ticks, IMaverickV2Pool.TickState[] memory tickStates);

    /**
     * @notice View function that provides information about pool ticks within
     * a range.  Information returned includes all pool state needed to emulate
     * a swap off chain. Ticks with no reserves are not included in part o f
     * the return array.
     */
    function getTicksAroundActiveWLiquidity(
        IMaverickV2Pool pool,
        int32 tickRadius
    )
        external
        view
        returns (
            int32[] memory ticks,
            IMaverickV2Pool.TickState[] memory tickStates,
            uint256[] memory liquidities,
            uint256[] memory sqrtLowerTickPrices,
            uint256[] memory sqrtUpperTickPrices,
            IMaverickV2Pool.State memory poolState,
            uint256 sqrtPrice,
            uint256 feeAIn,
            uint256 feeBIn
        );

    /**
     * @notice View function that provides pool state information.
     */
    function getFullPoolState(
        IMaverickV2Pool pool,
        uint32 binStart,
        uint32 binEnd
    ) external view returns (PoolState memory poolState);

    /**
     * @notice View function that provides price and liquidity of a given tick.
     */
    function getTickSqrtPriceAndL(
        IMaverickV2Pool pool,
        int32 tick
    ) external view returns (uint256 sqrtPrice, uint256 liquidity);

    /**
     * @notice Pool sqrt price.
     */
    function getPoolSqrtPrice(IMaverickV2Pool pool) external view returns (uint256 sqrtPrice);

    /**
     * @notice Pool price.
     */
    function getPoolPrice(IMaverickV2Pool pool) external view returns (uint256 price);

    /**
     * @notice Token scale of two tokens in a pool.
     */
    function tokenScales(IMaverickV2Pool pool) external view returns (uint256 tokenAScale, uint256 tokenBScale);
}

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

import {IMaverickV2Factory} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Factory.sol";
import {IMaverickV2Pool} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Pool.sol";
import {IMulticall} from "@maverick/v2-common/contracts/base/IMulticall.sol";
import {IPositionImage} from "./IPositionImage.sol";
import {INft} from "../positionbase/INft.sol";
import {IMigrateBins} from "../base/IMigrateBins.sol";
import {IChecks} from "../base/IChecks.sol";

interface IMaverickV2Position is INft, IMigrateBins, IMulticall, IChecks {
    event PositionClearData(uint256 indexed tokenId);
    event PositionSetData(uint256 indexed tokenId, uint256 index, PositionPoolBinIds newData);

    error PositionDuplicatePool(uint256 index, IMaverickV2Pool pool);
    error PositionNotFactoryPool();
    error PositionPermissionedLiquidityPool();

    struct PositionPoolBinIds {
        IMaverickV2Pool pool;
        uint32[] binIds;
    }

    struct PositionFullInformation {
        PositionPoolBinIds poolBinIds;
        uint256 amountA;
        uint256 amountB;
        uint256[] binAAmounts;
        uint256[] binBAmounts;
        int32[] ticks;
        uint256[] liquidities;
    }

    /**
     * @notice Contract that renders the position nft svg image.
     */
    function positionImage() external view returns (IPositionImage);

    /**
     * @notice Pool factory.
     */
    function factory() external view returns (IMaverickV2Factory);

    /**
     * @notice Mint NFT that holds liquidity in a Maverick V2 Pool. To mint
     * liquidity to an NFT, add liquidity to bins in a pool where the
     * add liquidity recipient is this contract and the subaccount is the
     * tokenId. LiquidityManager can be used to simplify minting Position NFTs.
     */
    function mint(address recipient, IMaverickV2Pool pool, uint32[] memory binIds) external returns (uint256 tokenId);

    /**
     * @notice Overwrites tokenId pool/binId information for a given data index.
     */
    function setTokenIdData(uint256 tokenId, uint256 index, IMaverickV2Pool pool, uint32[] memory binIds) external;

    /**
     * @notice Overwrites entire pool/binId data set for a given tokenId.
     */
    function setTokenIdData(uint256 tokenId, PositionPoolBinIds[] memory data) external;

    /**
     * @notice Append new pool/binIds data array to tokenId.
     */
    function appendTokenIdData(uint256 tokenId, IMaverickV2Pool pool, uint32[] memory binIds) external;

    /**
     * @notice Get array pool/binIds data for a given tokenId.
     */
    function getTokenIdData(uint256 tokenId) external view returns (PositionPoolBinIds[] memory);

    /**
     * @notice Get value from array of pool/binIds data for a given tokenId.
     */
    function getTokenIdData(uint256 tokenId, uint256 index) external view returns (PositionPoolBinIds memory);

    /**
     * @notice Length of array of pool/binIds data for a given tokenId.
     */
    function tokenIdDataLength(uint256 tokenId) external view returns (uint256 length);

    /**
     * @notice Remove liquidity from tokenId for a given pool.  User can
     * specify arbitrary bins to remove from for their subaccount in the pool
     * even if those bins are not in the tokenIdData set.
     */
    function removeLiquidity(
        uint256 tokenId,
        address recipient,
        IMaverickV2Pool pool,
        IMaverickV2Pool.RemoveLiquidityParams memory params
    ) external returns (uint256 tokenAAmount, uint256 tokenBAmount);

    /**
     * @notice Remove liquidity from tokenId for a given pool to sender.  User
     * can specify arbitrary bins to remove from for their subaccount in the
     * pool even if those bins are not in the tokenIdData set.
     */
    function removeLiquidityToSender(
        uint256 tokenId,
        IMaverickV2Pool pool,
        IMaverickV2Pool.RemoveLiquidityParams memory params
    ) external returns (uint256 tokenAAmount, uint256 tokenBAmount);

    /**
     * @notice NFT asset information for a given range of pool/binIds indexes.
     * This function only returns the liquidity in the pools/binIds stored as
     * part of the tokenIdData, but it is possible that the NFT has additional
     * liquidity in pools/binIds that have not been recorded.
     */
    function tokenIdPositionInformation(
        uint256 tokenId,
        uint256 startIndex,
        uint256 stopIndex
    ) external view returns (PositionFullInformation[] memory output);

    /**
     * @notice NFT asset information for a given pool/binIds index. This
     * function only returns the liquidity in the pools/binIds stored as part
     * of the tokenIdData, but it is possible that the NFT has additional
     * liquidity in pools/binIds that have not been recorded.
     */
    function tokenIdPositionInformation(
        uint256 tokenId,
        uint256 index
    ) external view returns (PositionFullInformation memory output);

    /**
     * @notice Get remove paramters for removing a fractional part of the
     * liquidity owned by a given tokenId.  The fractional factor to remove is
     * given by proporationD18 in 18-decimal scale.
     */
    function getRemoveParams(
        uint256 tokenId,
        uint256 index,
        uint256 proportionD18
    ) external view returns (IMaverickV2Pool.RemoveLiquidityParams memory params);
}

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

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

import {INft} from "@maverick/v2-supplemental/contracts/positionbase/INft.sol";
import {IMulticall} from "@maverick/v2-common/contracts/base/IMulticall.sol";

import {IMaverickV2VotingEscrow} from "./IMaverickV2VotingEscrow.sol";
import {IMaverickV2RewardVault} from "./IMaverickV2RewardVault.sol";
import {IRewardAccounting} from "../rewardbase/IRewardAccounting.sol";

interface IMaverickV2Reward is INft, IMulticall, IRewardAccounting {
    event NotifyRewardAmount(
        address sender,
        IERC20 rewardTokenAddress,
        uint256 amount,
        uint256 duration,
        uint256 rewardRate
    );
    event GetReward(
        address sender,
        uint256 tokenId,
        address recipient,
        uint8 rewardTokenIndex,
        uint256 stakeDuration,
        IERC20 rewardTokenAddress,
        RewardOutput rewardOutput,
        uint256 lockupId
    );
    event UnStake(
        address sender,
        uint256 tokenId,
        uint256 amount,
        address recipient,
        uint256 userBalance,
        uint256 totalSupply
    );
    event Stake(
        address sender,
        address supplier,
        uint256 amount,
        uint256 tokenId,
        uint256 userBalance,
        uint256 totalSupply
    );
    event AddRewardToken(IERC20 rewardTokenAddress, uint8 rewardTokenIndex);
    event RemoveRewardToken(IERC20 rewardTokenAddress, uint8 rewardTokenIndex);
    event ApproveRewardGetter(uint256 tokenId, address getter);

    error RewardDurationOutOfBounds(uint256 duration, uint256 minDuration, uint256 maxDuration);
    error RewardZeroAmount();
    error RewardNotValidRewardToken(IERC20 rewardTokenAddress);
    error RewardNotValidIndex(uint8 index);
    error RewardTokenCannotBeStakingToken(IERC20 stakingToken);
    error RewardTransferNotSupported();
    error RewardNotApprovedGetter(uint256 tokenId, address approved, address getter);
    error RewardUnboostedTimePeriodNotMet(uint256 timestamp, uint256 minTimestamp);

    struct RewardInfo {
        // Timestamp of when the rewards finish
        uint256 finishAt;
        // Minimum of last updated time and reward finish time
        uint256 updatedAt;
        // Reward to be paid out per second
        uint256 rewardRate;
        // Escrowed rewards
        uint256 escrowedReward;
        // Sum of (reward rate * dt * 1e18 / total supply)
        uint256 rewardPerTokenStored;
        // Reward Token to be emitted
        IERC20 rewardToken;
        // ve locking contract
        IMaverickV2VotingEscrow veRewardToken;
        // amount available to push to ve as incentive
        uint128 unboostedAmount;
        // timestamp of unboosted push
        uint256 lastUnboostedPushTimestamp;
    }

    struct ContractInfo {
        // Reward Name
        string name;
        // Reward Symbol
        string symbol;
        // total supply staked
        uint256 totalSupply;
        // staking token
        IERC20 stakingToken;
    }

    struct EarnedInfo {
        // earned
        uint256 earned;
        // reward token
        IERC20 rewardToken;
    }

    struct RewardOutput {
        uint256 amount;
        bool asVe;
        IMaverickV2VotingEscrow veContract;
    }

    // solhint-disable-next-line func-name-mixedcase
    function MAX_DURATION() external view returns (uint256);

    // solhint-disable-next-line func-name-mixedcase
    function MIN_DURATION() external view returns (uint256);

    /**
     * @notice This function retrieves the minimum time gap in seconds that
     * must have elasped between calls to `pushUnboostedToVe()`.
     */
    // solhint-disable-next-line func-name-mixedcase
    function UNBOOSTED_MIN_TIME_GAP() external view returns (uint256);

    /**
     * @notice This function retrieves the address of the token used for
     * staking in this reward contract.
     * @return The address of the staking token (IERC20).
     */
    function stakingToken() external view returns (IERC20);

    /**
     * @notice This function retrieves the address of the MaverickV2RewardVault
     * contract associated with this reward contract.
     * @return The address of the IMaverickV2RewardVault contract.
     */
    function vault() external view returns (IMaverickV2RewardVault);

    /**
     * @notice This function retrieves information about all available reward tokens for this reward contract.
     * @return info An array of RewardInfo structs containing details about each reward token.
     */
    function rewardInfo() external view returns (RewardInfo[] memory info);

    /**
     * @notice This function retrieves information about all available reward
     * tokens and overall contract details for this reward contract.
     * @return info An array of RewardInfo structs containing details about each reward token.
     * @return _contractInfo A ContractInfo struct containing overall contract details.
     */
    function contractInfo() external view returns (RewardInfo[] memory info, ContractInfo memory _contractInfo);

    /**
     * @notice This function calculates the total amount of all earned rewards
     * for a specific tokenId across all reward tokens.
     * @param tokenId The address of the tokenId for which to calculate earned rewards.
     * @return earnedInfo An array of EarnedInfo structs containing details about earned rewards for each supported token.
     */
    function earned(uint256 tokenId) external view returns (EarnedInfo[] memory earnedInfo);

    /**
     * @notice This function calculates the total amount of earned rewards for
     * a specific tokenId for a particular reward token.
     * @param tokenId The address of the tokenId for which to calculate earned rewards.
     * @param rewardTokenAddress The address of the specific reward token.
     * @return amount The total amount of earned rewards for the specified token.
     */
    function earned(uint256 tokenId, IERC20 rewardTokenAddress) external view returns (uint256);

    /**
     * @notice This function retrieves the internal index associated with a specific reward token address.
     * @param  rewardToken The address of the reward token to get the index for.
     * @return rewardTokenIndex The internal index of the token within the reward contract (uint8).
     */
    function tokenIndex(IERC20 rewardToken) external view returns (uint8 rewardTokenIndex);

    /**
     * @notice This function retrieves the total number of supported reward tokens in this reward contract.
     * @return count The total number of reward tokens (uint256).
     */
    function rewardTokenCount() external view returns (uint256);

    /**
     * @notice This function transfers a specified amount of reward tokens from
     * the caller to distribute them over a defined duration. The caller will
     * need to approve this rewards contract to make the transfer on the
     * caller's behalf. See `notifyRewardAmount` for details of how the
     * duration is set by the rewards contract.
     * @param rewardToken The address of the reward token to transfer.
     * @param duration The duration (in seconds) over which to distribute the rewards.
     * @param amount The amount of reward tokens to transfer.
     * @return _duration The duration in seconds that the incentives will be distributed over.
     */
    function transferAndNotifyRewardAmount(
        IERC20 rewardToken,
        uint256 duration,
        uint256 amount
    ) external returns (uint256 _duration);

    /**
     * @notice This function notifies the vault to distribute a previously
     * transferred amount of reward tokens over a defined duration. (Assumes
     * tokens are already in the contract).
     * @dev The duration of the distribution may not be the same as the input
     * duration.  If this notify amount is less than the amount already pending
     * disbursement, then this new amount will be distributed as the same rate
     * as the existing rate and that will dictate the duration.  Alternatively,
     * if the amount is more than the pending disbursement, then the input
     * duration will be honored and all pending disbursement tokens will also be
     * distributed at this newly set rate.
     * @param rewardToken The address of the reward token to distribute.
     * @param duration The duration (in seconds) over which to distribute the rewards.
     * @return _duration The duration in seconds that the incentives will be distributed over.
     */
    function notifyRewardAmount(IERC20 rewardToken, uint256 duration) external returns (uint256 _duration);

    /**
     * @notice This function transfers a specified amount of staking tokens
     * from the caller to the staking `vault()` and stakes them on the
     * recipient's behalf.  The user has to approve this reward contract to
     * transfer the staking token on their behalf for this function not to
     * revert.
     * @param tokenId Nft tokenId to stake for the staked tokens.
     * @param _amount The amount of staking tokens to transfer and stake.
     * @return amount The amount of staking tokens staked.  May differ from
     * input if there were unstaked tokens in the vault prior to this call.
     * @return stakedTokenId TokenId where liquidity was staked to.  This may
     * differ from the input tokenIf if the input `tokenId=0`.
     */
    function transferAndStake(
        uint256 tokenId,
        uint256 _amount
    ) external returns (uint256 amount, uint256 stakedTokenId);

    /**
     * @notice This function stakes the staking tokens to the specified
     * tokenId. If `tokenId=0` is passed in, then this function will look up
     * the caller's tokenIds and stake to the zero-index tokenId.  If the user
     * does not yet have a staking NFT tokenId, this function will mint one for
     * the sender and stake to that newly-minted tokenId.
     *
     * @dev The amount staked is derived by looking at the new balance on
     * the `vault()`. So, for staking to yield a non-zero balance, the user
     * will need to have transfered the `stakingToken()` to the `vault()` prior
     * to calling `stake`.  Note, tokens sent to the reward contract instead
     * of the vault will not be stakable and instead will be eligible to be
     * disbursed as rewards to stakers.  This is an advanced usage function.
     * If in doubt about the mechanics of staking, use `transferAndStake()`
     * instead.
     * @param tokenId The address of the tokenId whose tokens to stake.
     * @return amount The amount of staking tokens staked (uint256).
     * @return stakedTokenId TokenId where liquidity was staked to.  This may
     * differ from the input tokenIf if the input `tokenId=0`.
     */
    function stake(uint256 tokenId) external returns (uint256 amount, uint256 stakedTokenId);

    /**
     * @notice This function initiates unstaking of a specified amount of
     * staking tokens for the caller and sends them to a recipient.
     * @param tokenId The address of the tokenId whose tokens to unstake.
     * @param amount The amount of staking tokens to unstake (uint256).
     */
    function unstakeToOwner(uint256 tokenId, uint256 amount) external;

    /**
     * @notice This function initiates unstaking of a specified amount of
     * staking tokens on behalf of a specific tokenId and sends them to a recipient.
     * @dev To unstakeFrom, the caller must have an approval allowance of at
     * least `amount`.  Approvals follow the ERC-721 approval interface.
     * @param tokenId The address of the tokenId whose tokens to unstake.
     * @param recipient The address to which the unstaked tokens will be sent.
     * @param amount The amount of staking tokens to unstake (uint256).
     */
    function unstake(uint256 tokenId, address recipient, uint256 amount) external;

    /**
     * @notice This function retrieves the claimable reward for a specific
     * reward token and stake duration for the caller.
     * @param tokenId The address of the tokenId whose reward to claim.
     * @param rewardTokenIndex The internal index of the reward token.
     * @param stakeDuration The duration (in seconds) for which the rewards were staked.
     * @return rewardOutput A RewardOutput struct containing details about the claimable reward.
     */
    function getRewardToOwner(
        uint256 tokenId,
        uint8 rewardTokenIndex,
        uint256 stakeDuration
    ) external returns (RewardOutput memory rewardOutput);

    /**
     * @notice This function retrieves the claimable reward for a specific
     * reward token, stake duration, and lockup ID for the caller.
     * @param tokenId The address of the tokenId whose reward to claim.
     * @param rewardTokenIndex The internal index of the reward token.
     * @param stakeDuration The duration (in seconds) for which the rewards were staked.
     * @param lockupId The unique identifier for the specific lockup (optional).
     * @return rewardOutput A RewardOutput struct containing details about the claimable reward.
     */
    function getRewardToOwnerForExistingVeLockup(
        uint256 tokenId,
        uint8 rewardTokenIndex,
        uint256 stakeDuration,
        uint256 lockupId
    ) external returns (RewardOutput memory);

    /**
     * @notice This function retrieves the claimable reward for a specific
     * reward token and stake duration for a specified tokenId and sends it to
     * a recipient.  If the reward is staked in the corresponding veToken, a
     * new lockup in the ve token will be created.
     * @param tokenId The address of the tokenId whose reward to claim.
     * @param recipient The address to which the claimed reward will be sent.
     * @param rewardTokenIndex The internal index of the reward token.
     * @param stakeDuration The duration (in seconds) for which the rewards
     * will be staked in the ve contract.
     * @return rewardOutput A RewardOutput struct containing details about the claimable reward.
     */
    function getReward(
        uint256 tokenId,
        address recipient,
        uint8 rewardTokenIndex,
        uint256 stakeDuration
    ) external returns (RewardOutput memory);

    /**
     * @notice This function retrieves a list of all supported tokens in the reward contract.
     * @param includeStakingToken A flag indicating whether to include the staking token in the list.
     * @return tokens An array of IERC20 token addresses.
     */
    function tokenList(bool includeStakingToken) external view returns (IERC20[] memory tokens);

    /**
     * @notice This function retrieves the veToken contract associated with a
     * specific index within the reward contract.
     * @param index The index of the veToken to retrieve.
     * @return output The IMaverickV2VotingEscrow contract associated with the index.
     */
    function veTokenByIndex(uint8 index) external view returns (IMaverickV2VotingEscrow output);

    /**
     * @notice This function retrieves the reward token contract associated
     * with a specific index within the reward contract.
     * @param index The index of the reward token to retrieve.
     * @return output The IERC20 contract associated with the index.
     */
    function rewardTokenByIndex(uint8 index) external view returns (IERC20 output);

    /**
     * @notice This function calculates the boosted amount an tokenId would
     * receive based on their veToken balance and stake duration.
     * @param tokenId The address of the tokenId for which to calculate the boosted amount.
     * @param veToken The IMaverickV2VotingEscrow contract representing the veToken used for boosting.
     * @param rawAmount The raw (unboosted) amount.
     * @param stakeDuration The duration (in seconds) for which the rewards would be staked.
     * @return earnedAmount The boosted amount the tokenId would receive (uint256).
     * @return asVe A boolean indicating whether the boosted amount is
     * staked in the veToken (true) or is disbursed without ve staking required (false).
     */
    function boostedAmount(
        uint256 tokenId,
        IMaverickV2VotingEscrow veToken,
        uint256 rawAmount,
        uint256 stakeDuration
    ) external view returns (uint256 earnedAmount, bool asVe);

    /**
     * @notice This function is used to push unboosted rewards to the veToken
     * contract.  This unboosted reward amount is then distributed to the
     * veToken holders. This function will revert if less than
     * `UNBOOSTED_MIN_TIME_GAP()` seconds have passed since the last call.
     * @param rewardTokenIndex The internal index of the reward token.
     * @return amount The amount of unboosted rewards pushed (uint128).
     * @return timepoint The timestamp associated with the pushed rewards (uint48).
     * @return batchIndex The batch index for the pushed rewards (uint256).
     */
    function pushUnboostedToVe(
        uint8 rewardTokenIndex
    ) external returns (uint128 amount, uint48 timepoint, uint256 batchIndex);

    /**
     * @notice Mints an NFT stake to a user.  This NFT will not possesses any
     * assets until a user `stake`s asset to the NFT tokenId as part of a
     * separate call.
     * @param recipient The address that owns the output NFT
     */
    function mint(address recipient) external returns (uint256 tokenId);

    /**
     * @notice Mints an NFT stake to caller.  This NFT will not possesses any
     * assets until a user `stake`s asset to the NFT tokenId as part of a
     * separate call.
     */
    function mintToSender() external returns (uint256 tokenId);
}

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

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IMaverickV2BoostedPositionFactory} from "@maverick/v2-supplemental/contracts/interfaces/IMaverickV2BoostedPositionFactory.sol";

import {IMaverickV2VotingEscrowFactory} from "./IMaverickV2VotingEscrowFactory.sol";
import {IMaverickV2VotingEscrow} from "./IMaverickV2VotingEscrow.sol";
import {IMaverickV2Reward} from "./IMaverickV2Reward.sol";

interface IMaverickV2RewardFactory {
    error RewardFactoryNotFactoryBoostedPosition();
    error RewardFactoryTooManyRewardTokens();
    error RewardFactoryRewardAndVeLengthsAreNotEqual();
    error RewardFactoryInvalidVeBaseTokenPair();

    event CreateRewardsContract(
        IERC20 stakeToken,
        IERC20[] rewardTokens,
        IMaverickV2VotingEscrow[] veTokens,
        IMaverickV2Reward rewardsContract,
        bool isFactoryBoostedPosition
    );

    /**
     * @notice This function creates a new MaverickV2Reward contract associated
     * with a specific stake token contract and set of reward and voting
     * escrow tokens.
     * @param stakeToken Token to be staked in reward contract; e.g. a boosted position contract.
     * @param rewardTokens An array of IERC20 token addresses representing the available reward tokens.
     * @param veTokens An array of IMaverickV2VotingEscrow contract addresses
     * representing the associated veTokens for boosting.
     * @return rewardsContract The newly created IMaverickV2Reward contract.
     */
    function createRewardsContract(
        IERC20 stakeToken,
        IERC20[] memory rewardTokens,
        IMaverickV2VotingEscrow[] memory veTokens
    ) external returns (IMaverickV2Reward rewardsContract);

    /**
     * @notice This function retrieves the address of the MaverickV2BoostedPositionFactory contract.
     * @return factory The address of the IMaverickV2BoostedPositionFactory contract.
     */
    function boostedPositionFactory() external returns (IMaverickV2BoostedPositionFactory);

    /**
     * @notice This function retrieves the address of the MaverickV2VotingEscrowFactory contract.
     * @return factory The address of the IMaverickV2VotingEscrowFactory contract.
     */
    function votingEscrowFactory() external returns (IMaverickV2VotingEscrowFactory);

    /**
     * @notice This function checks if a provided IMaverickV2Reward contract is
     * a valid contract created by this factory.
     * @param reward The IMaverickV2Reward contract to check.
     * @return isFactoryContract True if the contract is a valid factory-created reward contract, False otherwise.
     */
    function isFactoryContract(IMaverickV2Reward reward) external returns (bool);

    /**
     * @notice This function retrieves a list of all MaverickV2Reward contracts
     * associated with a specific staking token contract within a specified
     * range.
     * @param stakeToken Lookup token.
     * @param startIndex The starting index of the list to retrieve.
     * @param endIndex The ending index of the list to retrieve.
     * @return rewardsContract An array of IMaverickV2Reward contracts
     * associated with the BoostedPosition within the specified range.
     */
    function rewardsForStakeToken(
        IERC20 stakeToken,
        uint256 startIndex,
        uint256 endIndex
    ) external view returns (IMaverickV2Reward[] memory rewardsContract);

    /**
     * @notice Returns the number of reward contracts this factory has deployed
     * for a given staking token.
     */
    function rewardsForStakeTokenCount(IERC20 stakeToken) external view returns (uint256 count);

    /**
     * @notice This function retrieves a list of all MaverickV2Reward contracts within a specified range.
     * @param startIndex The starting index of the list to retrieve.
     * @param endIndex The ending index of the list to retrieve.
     * @return rewardsContract An array of IMaverickV2Reward contracts within the specified range.
     */
    function rewards(
        uint256 startIndex,
        uint256 endIndex
    ) external view returns (IMaverickV2Reward[] memory rewardsContract);

    /**
     * @notice Returns the number of reward contracts this factory has deployed.
     */
    function rewardsCount() external view returns (uint256 count);

    /**
     * @notice This function retrieves a list of all MaverickV2Reward contracts
     * within a specified range that have a staking token that is a boosted
     * position from the maverick boosted position contract.
     * @param startIndex The starting index of the list to retrieve.
     * @param endIndex The ending index of the list to retrieve.
     * @return rewardsContract An array of IMaverickV2Reward contracts within the specified range.
     */
    function boostedPositionRewards(
        uint256 startIndex,
        uint256 endIndex
    ) external view returns (IMaverickV2Reward[] memory);

    /**
     * @notice Returns the number of reward contracts where the staking token
     * is a booste position that this factory has deployed.
     */
    function boostedPositionRewardsCount() external view returns (uint256 count);

    /**
     * @notice This function retrieves a list of all MaverickV2Reward contracts
     * within a specified range that have a staking token that is not a boosted
     * position from the maverick boosted position contract.
     * @param startIndex The starting index of the list to retrieve.
     * @param endIndex The ending index of the list to retrieve.
     * @return rewardsContract An array of IMaverickV2Reward contracts within the specified range.
     */
    function nonBoostedPositionRewards(
        uint256 startIndex,
        uint256 endIndex
    ) external view returns (IMaverickV2Reward[] memory);

    /**
     * @notice Returns the number of reward contracts where the staking token
     * is not a booste position that this factory has deployed.
     */
    function nonBoostedPositionRewardsCount() external view returns (uint256 count);
}

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

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IMaverickV2PoolLens} from "@maverick/v2-supplemental/contracts/interfaces/IMaverickV2PoolLens.sol";
import {IMaverickV2BoostedPosition} from "@maverick/v2-supplemental/contracts/interfaces/IMaverickV2BoostedPosition.sol";
import {IMaverickV2LiquidityManager} from "@maverick/v2-supplemental/contracts/interfaces/IMaverickV2LiquidityManager.sol";

import {IMaverickV2RewardFactory} from "./IMaverickV2RewardFactory.sol";
import {IMaverickV2VotingEscrowWSync} from "./IMaverickV2VotingEscrowWSync.sol";
import {IMaverickV2Reward} from "./IMaverickV2Reward.sol";
import {IMaverickV2VotingEscrow} from "./IMaverickV2VotingEscrow.sol";

interface IMaverickV2RewardRouter is IMaverickV2LiquidityManager {
    /**
     * @notice This function stakes any new staking token balance that are in
     * the `reward.vault()` for a specified recipient tokenId.  Passing input
     * `tokenId=0` will cause the stake to mint to either the first tokenId for
     * the caller, or a new NFT tokenId if the sender does not yet have one.
     * @param reward The IMaverickV2Reward contract for which to stake.
     * @param tokenId Nft tokenId to stake for the staked tokens.
     * @return amount The amount of staking tokens staked.  May differ from
     * input if there were unstaked tokens in the vault prior to this call.
     * @return stakedTokenId TokenId where liquidity was staked to.  This may
     * differ from the input tokenId if the input `tokenId=0`.
     */
    function stake(
        IMaverickV2Reward reward,
        uint256 tokenId
    ) external payable returns (uint256 amount, uint256 stakedTokenId);

    /**
     * @notice This function retrieves the address of the MaverickV2RewardFactory
     * contract associated with this contract.
     */
    function rewardFactory() external view returns (IMaverickV2RewardFactory);

    /**
     * @notice This function transfers a specified amount of reward tokens from
     * the caller to a reward contract and notifies it to distribute them over
     * a defined duration.
     * @param reward The IMaverickV2Reward contract to notify.
     * @param rewardToken The address of the reward token to transfer.
     * @param duration The duration (in seconds) over which to distribute the rewards.
     * @return _duration The duration in seconds that the incentives will be distributed over.
     */
    function notifyRewardAmount(
        IMaverickV2Reward reward,
        IERC20 rewardToken,
        uint256 duration
    ) external payable returns (uint256 _duration);

    /**
     * @notice This function transfers a specified amount of staking tokens from
     * the caller, stakes them on the recipient's behalf, and
     * associates them with a specified reward contract.
     * @param reward The IMaverickV2Reward contract for which to stake.
     * @param tokenId Nft tokenId to stake for the staked tokens.
     * @param _amount The amount of staking tokens to transfer and stake.
     * @return amount The amount of staking tokens staked.  May differ from
     * input if there were unstaked tokens in the vault prior to this call.
     * @return stakedTokenId TokenId where liquidity was staked to.  This may
     * differ from the input tokenIf if the input `tokenId=0`.
     *
     */
    function transferAndStake(
        IMaverickV2Reward reward,
        uint256 tokenId,
        uint256 _amount
    ) external payable returns (uint256 amount, uint256 stakedTokenId);

    /**
     * @notice This function transfers a specified amount of reward tokens
     *  from the caller and adds them to the reward contract as incentives.
     * @param reward The IMaverickV2Reward contract to notify.
     * @param rewardToken The address of the reward token to transfer.
     * @param duration The duration (in seconds) over which to distribute the rewards.
     * @param amount The amount of staking tokens to stake (uint256).
     * @return _duration The duration in seconds that the incentives will be distributed over.
     */
    function transferAndNotifyRewardAmount(
        IMaverickV2Reward reward,
        IERC20 rewardToken,
        uint256 duration,
        uint256 amount
    ) external payable returns (uint256 _duration);

    /**
     * @notice This function creates a new BoostedPosition contract, adds
     * liquidity to a pool using the provided parameters, stakes the received
     * LP tokens, and associates them with a specified reward contract.
     * @param recipient The address to which the minted LP tokens will be
     * credited.
     * @param params A struct containing parameters for creating the
     * BoostedPosition (see IMaverickV2PoolLens.CreateBoostedPositionInputs).
     * @param rewardTokens An array of IERC20 token addresses representing the
     * available reward tokens for the staked LP position.
     * @param veTokens An array of IMaverickV2VotingEscrow contract addresses
     * representing the veTokens used for boosting.
     * @return boostedPosition The created IMaverickV2BoostedPosition contract.
     * @return mintedLpAmount The amount of LP tokens minted from the added liquidity.
     * @return tokenAAmount The amount of token A deposited for liquidity.
     * @return tokenBAmount The amount of token B deposited for liquidity.
     * @return stakeAmount The amount of LP tokens staked in the reward contract.
     * @return reward The IMaverickV2Reward contract.
     * @return tokenId Token on reward contract where user liquidity was staked.
     */
    function createBoostedPositionAndAddLiquidityAndStake(
        address recipient,
        IMaverickV2PoolLens.CreateBoostedPositionInputs memory params,
        IERC20[] memory rewardTokens,
        IMaverickV2VotingEscrow[] memory veTokens
    )
        external
        payable
        returns (
            IMaverickV2BoostedPosition boostedPosition,
            uint256 mintedLpAmount,
            uint256 tokenAAmount,
            uint256 tokenBAmount,
            uint256 stakeAmount,
            IMaverickV2Reward reward,
            uint256 tokenId
        );

    /**
     * @notice This function is similar to
     * `createBoostedPositionAndAddLiquidityAndStake` but stakes the minted LP
     * tokens for the caller (msg.sender) instead of a specified recipient.
     * @param params A struct containing parameters for creating the
     * BoostedPosition (see IMaverickV2PoolLens.CreateBoostedPositionInputs).
     * @param rewardTokens An array of IERC20 token addresses representing the
     * available reward tokens for the staked LP position.
     * @param veTokens An array of IMaverickV2VotingEscrow contract addresses
     * representing the veTokens used for boosting.
     * @return boostedPosition The created IMaverickV2BoostedPosition contract.
     * @return mintedLpAmount The amount of LP tokens minted from the added liquidity.
     * @return tokenAAmount The amount of token A deposited for liquidity.
     * @return tokenBAmount The amount of token B deposited for liquidity.
     * @return stakeAmount The amount of LP tokens staked in the reward contract.
     * @return reward The IMaverickV2Reward contract associated with the staked LP position.
     * @return tokenId Token on reward contract where user liquidity was staked.
     */
    function createBoostedPositionAndAddLiquidityAndStakeToSender(
        IMaverickV2PoolLens.CreateBoostedPositionInputs memory params,
        IERC20[] memory rewardTokens,
        IMaverickV2VotingEscrow[] memory veTokens
    )
        external
        payable
        returns (
            IMaverickV2BoostedPosition boostedPosition,
            uint256 mintedLpAmount,
            uint256 tokenAAmount,
            uint256 tokenBAmount,
            uint256 stakeAmount,
            IMaverickV2Reward reward,
            uint256 tokenId
        );

    /**
     * @notice This function adds liquidity to a pool using a pre-created
     * BoostedPosition contract, stakes the received LP tokens, and associates
     * them with a specified reward contract.
     * @param tokenId Token on reward contract where liquidity is to be staked.
     * @param boostedPosition The IMaverickV2BoostedPosition contract representing the existing boosted position.
     * @param packedSqrtPriceBreaks A packed representation of sqrt price
     * breaks for the liquidity range (see
     * IMaverickV2Pool.IAddLiquidityParams).
     * @param packedArgs Additional packed arguments for adding liquidity (see
     * IMaverickV2Pool.IAddLiquidityParams).
     * @param reward The IMaverickV2Reward contract for which to stake the LP tokens.
     * @return mintedLpAmount The amount of LP tokens minted from the added liquidity.
     * @return tokenAAmount The amount of token A deposited for liquidity.
     * @return tokenBAmount The amount of token B deposited for liquidity.
     * @return stakeAmount The amount of LP tokens staked in the reward contract.
     *
     */
    function addLiquidityAndMintBoostedPositionAndStake(
        uint256 tokenId,
        IMaverickV2BoostedPosition boostedPosition,
        bytes memory packedSqrtPriceBreaks,
        bytes[] memory packedArgs,
        IMaverickV2Reward reward
    )
        external
        payable
        returns (uint256 mintedLpAmount, uint256 tokenAAmount, uint256 tokenBAmount, uint256 stakeAmount);

    /**
     * @notice This function is similar to
     * `addLiquidityAndMintBoostedPositionAndStake` but uses the caller
     * (msg.sender) as the recipient for the minted reward stake.
     * @param sendersTokenIndex Token index of sender on the reward contract to
     * mint to.  If sender does not have a token already, then this call will
     * mint one for the user.
     * @param boostedPosition The IMaverickV2BoostedPosition contract representing the existing boosted position.
     * @param packedSqrtPriceBreaks A packed representation of sqrt price breaks for the liquidity range (see IMaverickV2Pool.IAddLiquidityParams).
     * @param packedArgs Additional packed arguments for adding liquidity (see IMaverickV2Pool.IAddLiquidityParams).
     * @param reward The IMaverickV2Reward contract for which to stake the LP tokens.
     * @return mintedLpAmount The amount of LP tokens minted from the added liquidity.
     * @return tokenAAmount The amount of token A deposited for liquidity.
     * @return tokenBAmount The amount of token B deposited for liquidity.
     * @return stakeAmount The amount of LP tokens staked in the reward contract.
     * @return tokenId Token on reward contract where user liquidity was staked.
     */
    function addLiquidityAndMintBoostedPositionAndStakeToSender(
        uint256 sendersTokenIndex,
        IMaverickV2BoostedPosition boostedPosition,
        bytes memory packedSqrtPriceBreaks,
        bytes[] memory packedArgs,
        IMaverickV2Reward reward
    )
        external
        payable
        returns (
            uint256 mintedLpAmount,
            uint256 tokenAAmount,
            uint256 tokenBAmount,
            uint256 stakeAmount,
            uint256 tokenId
        );

    /**
     * @notice This function syncs the balance of a staker's votes on the
     * legacy ve mav contract with the new V2 ve mav contract.
     * @param ve The IMaverickV2VotingEscrowWSync contract to interact with.
     * @param staker The address of the user whose veToken lock may need syncing.
     * @param  legacyLockupIndexes A list of indexes to synchronize from the
     * legacy veMav to the V2 ve contract.
     *
     */
    function sync(
        IMaverickV2VotingEscrowWSync ve,
        address staker,
        uint256[] memory legacyLockupIndexes
    ) external returns (uint256[] memory newBalance);

    function mintTokenInRewardToSender(IMaverickV2Reward reward) external payable returns (uint256 tokenId);

    function mintTokenInReward(IMaverickV2Reward reward, address recipient) external payable returns (uint256 tokenId);
}

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

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

interface IMaverickV2RewardVault {
    error RewardVaultUnauthorizedAccount(address caller, address owner);

    /**
     * @notice This function allows the owner of the reward vault to withdraw a
     * specified amount of staking tokens to a recipient address.  If non-owner
     * calls this function, it will revert.
     * @param recipient The address to which the withdrawn staking tokens will be sent.
     * @param amount The amount of staking tokens to withdraw.
     */
    function withdraw(address recipient, uint256 amount) external;

    /**
     * @notice This function retrieves the address of the owner of the reward
     * vault contract.
     */
    function owner() external view returns (address);

    /**
     * @notice This function retrieves the address of the ERC20 token used for
     * staking within the reward vault.
     */
    function stakingToken() external view returns (IERC20);
}

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

import {IVotes} from "@openzeppelin/contracts/governance/utils/IVotes.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {IERC6372} from "@openzeppelin/contracts/interfaces/IERC6372.sol";

import {IHistoricalBalance} from "../votingescrowbase/IHistoricalBalance.sol";

interface IMaverickV2VotingEscrowBase is IVotes, IHistoricalBalance {
    error VotingEscrowTransferNotSupported();
    error VotingEscrowInvalidAddress(address);
    error VotingEscrowInvalidAmount(uint256);
    error VotingEscrowInvalidDuration(uint256 duration, uint256 minDuration, uint256 maxDuration);
    error VotingEscrowInvalidEndTime(uint256 newEnd, uint256 oldEnd);
    error VotingEscrowStakeStillLocked(uint256 currentTime, uint256 endTime);
    error VotingEscrowStakeAlreadyRedeemed();
    error VotingEscrowNotApprovedExtender(address account, address extender, uint256 lockupId);
    error VotingEscrowIncentiveAlreadyClaimed(address account, uint256 batchIndex);
    error VotingEscrowNoIncentivesToClaim(address account, uint256 batchIndex);
    error VotingEscrowInvalidExtendIncentiveToken(IERC20 incentiveToken);
    error VotingEscrowNoSupplyAtTimepoint();
    error VotingEscrowIncentiveTimepointInFuture(uint256 timestamp, uint256 claimTimepoint);

    event Stake(address indexed user, uint256 lockupId, Lockup);
    event Unstake(address indexed user, uint256 lockupId, Lockup);
    event ExtenderApproval(address staker, address extender, uint256 lockupId, bool newState);
    event ClaimIncentiveBatch(uint256 batchIndex, address account, uint256 claimAmount);
    event CreateNewIncentiveBatch(
        address user,
        uint256 amount,
        uint256 timepoint,
        uint256 stakeDuration,
        IERC20 incentiveToken
    );

    struct Lockup {
        uint128 amount;
        uint128 end;
        uint256 votes;
    }

    struct ClaimInformation {
        bool timepointInPast;
        bool hasClaimed;
        uint128 claimAmount;
    }

    struct BatchInformation {
        uint128 totalIncentives;
        uint128 stakeDuration;
        uint48 claimTimepoint;
        IERC20 incentiveToken;
    }

    struct TokenIncentiveTotals {
        uint128 totalIncentives;
        uint128 claimedIncentives;
    }

    // solhint-disable-next-line func-name-mixedcase
    function MIN_STAKE_DURATION() external returns (uint256 duration);

    // solhint-disable-next-line func-name-mixedcase
    function MAX_STAKE_DURATION() external returns (uint256 duration);

    // solhint-disable-next-line func-name-mixedcase
    function YEAR_BASE() external returns (uint256);

    /**
     * @notice This function retrieves the address of the ERC20 token used as the base token for staking and rewards.
     * @return baseToken The address of the IERC20 base token contract.
     */
    function baseToken() external returns (IERC20);

    /**
     * @notice This function retrieves the starting timestamp. This may be used
     * for reward calculations or other time-based logic.
     */
    function startTimestamp() external returns (uint256 timestamp);

    /**
     * @notice This function retrieves the details of a specific lockup for a given staker and lockup index.
     * @param staker The address of the staker for which to retrieve the lockup details.
     * @param index The index of the lockup within the staker's lockup history.
     * @return lockup A Lockup struct containing details about the lockup (see struct definition for details).
     */
    function getLockup(address staker, uint256 index) external view returns (Lockup memory lockup);

    /**
     * @notice This function retrieves the total number of lockups associated with a specific staker.
     * @param staker The address of the staker for which to retrieve the lockup count.
     * @return count The total number of lockups for the staker.
     */
    function lockupCount(address staker) external view returns (uint256 count);

    /**
     * @notice This function simulates a lockup scenario, providing details about the resulting lockup structure for a specified amount and duration.
     * @param amount The amount of tokens to be locked.
     * @param duration The duration of the lockup period.
     * @return lockup A Lockup struct containing details about the simulated lockup (see struct definition for details).
     */
    function previewVotes(uint128 amount, uint256 duration) external view returns (Lockup memory lockup);

    /**
     * @notice This function grants approval for a designated extender contract to manage a specific lockup on behalf of the staker.
     * @param extender The address of the extender contract to be approved.
     * @param lockupId The ID of the lockup for which to grant approval.
     */
    function approveExtender(address extender, uint256 lockupId) external;

    /**
     * @notice This function revokes approval previously granted to an extender contract for managing a specific lockup.
     * @param extender The address of the extender contract whose approval is being revoked.
     * @param lockupId The ID of the lockup for which to revoke approval.
     */
    function revokeExtender(address extender, uint256 lockupId) external;

    /**
     * @notice This function checks whether a specific account has been approved by a staker to manage a particular lockup through an extender contract.
     * @param account The address of the account to check for approval (may be the extender or another account).
     * @param extender The address of the extender contract for which to check approval.
     * @param lockupId The ID of the lockup to verify approval for.
     * @return isApproved True if the account is approved for the lockup, False otherwise (bool).
     */
    function isApprovedExtender(address account, address extender, uint256 lockupId) external view returns (bool);

    /**
     * @notice This function extends the lockup period for the caller (msg.sender) for a specified lockup ID, adding a new duration and amount.
     * @param lockupId The ID of the lockup to be extended.
     * @param duration The additional duration to extend the lockup by.
     * @param amount The additional amount of tokens to be locked.
     * @return newLockup A Lockup struct containing details about the newly extended lockup (see struct definition for details).
     */
    function extendForSender(
        uint256 lockupId,
        uint256 duration,
        uint128 amount
    ) external returns (Lockup memory newLockup);

    /**
     * @notice This function extends the lockup period for a specified account, adding a new duration and amount. The caller (msg.sender) must be authorized to manage the lockup through an extender contract.
     * @param account The address of the account whose lockup is being extended.
     * @param lockupId The ID of the lockup to be extended.
     * @param duration The additional duration to extend the lockup by.
     * @param amount The additional amount of tokens to be locked.
     * @return newLockup A Lockup struct containing details about the newly extended lockup (see struct definition for details).
     */
    function extendForAccount(
        address account,
        uint256 lockupId,
        uint256 duration,
        uint128 amount
    ) external returns (Lockup memory newLockup);

    /**
     * @notice This function merges multiple lockups associated with the caller
     * (msg.sender) into a single new lockup.
     * @param lockupIds An array containing the IDs of the lockups to be merged.
     * @return newLockup A Lockup struct containing details about the newly merged lockup (see struct definition for details).
     */
    function merge(uint256[] memory lockupIds) external returns (Lockup memory newLockup);

    /**
     * @notice This function unstakes the specified lockup ID for the caller (msg.sender), returning the details of the unstaked lockup.
     * @param lockupId The ID of the lockup to be unstaked.
     * @param to The address to which the unstaked tokens should be sent (optional, defaults to msg.sender).
     * @return lockup A Lockup struct containing details about the unstaked lockup (see struct definition for details).
     */
    function unstake(uint256 lockupId, address to) external returns (Lockup memory lockup);

    /**
     * @notice This function is a simplified version of `unstake` that automatically sends the unstaked tokens to the caller (msg.sender).
     * @param lockupId The ID of the lockup to be unstaked.
     * @return lockup A Lockup struct containing details about the unstaked lockup (see struct definition for details).
     */
    function unstakeToSender(uint256 lockupId) external returns (Lockup memory lockup);

    /**
     * @notice This function stakes a specified amount of tokens for the caller
     * (msg.sender) for a defined duration.
     * @param amount The amount of tokens to be staked.
     * @param duration The duration of the lockup period.
     * @return lockup A Lockup struct containing details about the newly
     * created lockup (see struct definition for details).
     */
    function stakeToSender(uint128 amount, uint256 duration) external returns (Lockup memory lockup);

    /**
     * @notice This function stakes a specified amount of tokens for a defined
     * duration, allowing the caller (msg.sender) to specify an optional
     * recipient for the staked tokens.
     * @param amount The amount of tokens to be staked.
     * @param duration The duration of the lockup period.
     * @param to The address to which the staked tokens will be credited (optional, defaults to msg.sender).
     * @return lockup A Lockup struct containing details about the newly
     * created lockup (see struct definition for details).
     */
    function stake(uint128 amount, uint256 duration, address to) external returns (Lockup memory);

    /**
     * @notice This function retrieves the total incentive information for a specific ERC-20 token.
     * @param token The address of the ERC20 token for which to retrieve incentive totals.
     * @return totals A TokenIncentiveTotals struct containing details about
     * the token's incentives (see struct definition for details).
     */
    function incentiveTotals(IERC20 token) external view returns (TokenIncentiveTotals memory);

    /**
     * @notice This function retrieves the total number of created incentive batches.
     * @return count The total number of incentive batches.
     */
    function incentiveBatchCount() external view returns (uint256);

    /**
     * @notice This function retrieves claim information for a specific account and incentive batch index.
     * @param account The address of the account for which to retrieve claim information.
     * @param batchIndex The index of the incentive batch for which to retrieve
     * claim information.
     * @return claimInformation A ClaimInformation struct containing details about the
     * account's claims for the specified batch (see struct definition for
     * details).
     * @return batchInformation A BatchInformation struct containing details about the
     * specified batch (see struct definition for details).
     */
    function claimAndBatchInformation(
        address account,
        uint256 batchIndex
    ) external view returns (ClaimInformation memory claimInformation, BatchInformation memory batchInformation);

    /**
     * @notice This function retrieves batch information for a incentive batch index.
     * @param batchIndex The index of the incentive batch for which to retrieve
     * claim information.
     * @return info A BatchInformation struct containing details about the
     * specified batch (see struct definition for details).
     */
    function incentiveBatchInformation(uint256 batchIndex) external view returns (BatchInformation memory info);

    /**
     * @notice This function allows claiming rewards from a specific incentive
     * batch while simultaneously extending a lockup with the claimed tokens.
     * @param batchIndex The index of the incentive batch from which to claim rewards.
     * @param lockupId The ID of the lockup to be extended with the claimed tokens.
     * @return lockup A Lockup struct containing details about the updated
     * lockup after extension (see struct definition for details).
     * @return claimAmount The amount of tokens claimed from the incentive batch.
     */
    function claimFromIncentiveBatchAndExtend(
        uint256 batchIndex,
        uint256 lockupId
    ) external returns (Lockup memory lockup, uint128 claimAmount);

    /**
     * @notice This function allows claiming rewards from a specific incentive
     * batch, without extending any lockups.
     * @param batchIndex The index of the incentive batch from which to claim rewards.
     * @return lockup A Lockup struct containing details about the user's
     * lockup that might have been affected by the claim (see struct definition
     * for details).
     * @return claimAmount The amount of tokens claimed from the incentive batch.
     */
    function claimFromIncentiveBatch(uint256 batchIndex) external returns (Lockup memory lockup, uint128 claimAmount);

    /**
     * @notice This function creates a new incentive batch for a specified amount
     * of incentive tokens, timepoint, stake duration, and associated ERC-20
     * token. An incentive batch is a reward of incentives put up by the
     * caller at a certain timepoint.  The incentive batch is claimable by ve
     * holders after the timepoint has passed.  The ve holders will receive
     * their incentive pro rata of their vote balance (`pastbalanceOf`) at that
     * timepoint.  The incentivizer can specify that users have to stake the
     * resulting incentive for a given `stakeDuration` number of seconds.
     * `stakeDuration` can either be zero, meaning that no staking is required
     * on redemption, or can be a number between `MIN_STAKE_DURATION()` and
     * `MAX_STAKE_DURATION()`.
     * @param amount The total amount of incentive tokens to be distributed in the batch.
     * @param timepoint The timepoint at which the incentive batch starts accruing rewards.
     * @param stakeDuration The duration of the lockup period required to be
     * eligible for the incentive batch rewards.
     * @param incentiveToken The address of the ERC20 token used for the incentive rewards.
     * @return index The index of the newly created incentive batch.
     */
    function createIncentiveBatch(
        uint128 amount,
        uint48 timepoint,
        uint128 stakeDuration,
        IERC20 incentiveToken
    ) external returns (uint256 index);
}

interface IMaverickV2VotingEscrow is IMaverickV2VotingEscrowBase, IERC20Metadata, IERC6372 {}

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

import {IERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IMaverickV2VotingEscrow} from "./IMaverickV2VotingEscrow.sol";

interface IMaverickV2VotingEscrowFactory {
    error VotingEscrowTokenAlreadyExists(IERC20 baseToken, IMaverickV2VotingEscrow veToken);

    event CreateVotingEscrow(IERC20 baseToken, IMaverickV2VotingEscrow veToken);

    /**
     * @notice This function retrieves the address of the legacy Maverick V1
     * Voting Escrow (veMAV) token.  The address will be zero for blockchains
     * where this contract is deployed that do not have a legacy MAV contract
     * deployed.
     * @return legacyVeMav The address of the IERC20 legacy veMav token.
     */
    function legacyVeMav() external view returns (IERC20);

    /**
     * @notice This function checks whether a provided IMaverickV2VotingEscrow
     * contract address was created by this factory.
     * @param veToken The address of the IMaverickV2VotingEscrow contract to be checked.
     * @return isFactoryToken True if the veToken was created by this factory, False otherwise (bool).
     */
    function isFactoryToken(IMaverickV2VotingEscrow veToken) external view returns (bool);

    /**
     * @notice This function creates a new Maverick V2 Voting Escrow (veToken)
     * contract for a specified ERC20 base token.
     * @dev Once the ve contract is created, it will call `name()` and
     * `symbol()` on the `baseToken`.  If those functions do not exist, the ve
     * creation will revert.
     * @param baseToken The address of the ERC-20 token to be used as the base token for the new veToken.
     * @return veToken The address of the newly created IMaverickV2VotingEscrow contract.
     */
    function createVotingEscrow(IERC20 baseToken) external returns (IMaverickV2VotingEscrow veToken);

    /**
     * @notice This function retrieves a paginated list of existing Maverick V2
     * Voting Escrow (veToken) contracts within a specified index range.
     * @param startIndex The starting index for the desired range of veTokens.
     * @param endIndex The ending index for the desired range of veTokens.
     * @return votingEscrows An array of IMaverickV2VotingEscrow addresses
     * representing the veTokens within the specified range.
     */
    function votingEscrows(
        uint256 startIndex,
        uint256 endIndex
    ) external view returns (IMaverickV2VotingEscrow[] memory votingEscrows);

    /**
     * @notice This function retrieves the total number of deployed Maverick V2
     * Voting Escrow (veToken) contracts.
     * @return count The total number of veTokens.
     */
    function votingEscrowsCount() external view returns (uint256 count);

    /**
     * @notice This function retrieves the address of the existing Maverick V2
     * Voting Escrow (veToken) contract associated with a specific ERC20 base
     * token.
     * @param baseToken The address of the ERC-20 base token for which to retrieve the veToken address.
     * @return veToken The address of the IMaverickV2VotingEscrow contract
     * associated with the base token, or the zero address if none exists.
     */
    function veForBaseToken(IERC20 baseToken) external view returns (IMaverickV2VotingEscrow veToken);

    /**
     * @notice This function retrieves the default base token used for creating
     * new voting escrow contracts.  This state variable is only used
     * temporarily when a new veToken is deployed.
     * @return baseToken The address of the default ERC-20 base token.
     */
    function baseTokenParameter() external returns (IERC20);
}

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

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

interface IMaverickV2VotingEscrowWSync {
    error VotingEscrowLockupEndTooShortToSync(uint256 legacyLockupEnd, uint256 minimumLockupEnd);

    event Sync(address staker, uint256 legacyLockupIndex, uint256 newBalance);

    /**
     * @notice This function retrieves the minimum lockup duration required for
     * a legacy lockup to be eligible for synchronization.
     * @return minSyncDuration The minimum allowed lockup end time.
     */
    // solhint-disable-next-line func-name-mixedcase
    function MIN_SYNC_DURATION() external pure returns (uint256 minSyncDuration);

    /**
     * @notice This function retrieves the address of the legacy Maverick V1
     * Voting Escrow (veMav) token.
     * @return legacyVeMav The address of the IERC20 legacy veMav token.
     */
    function legacyVeMav() external view returns (IERC20);

    /**
     * @notice This function retrieves the synced balance for a specific legacy lockup index of a user.
     * @param staker The address of the user for whom to retrieve the synced balance.
     * @param legacyLockupIndex The index of the legacy lockup for which to
     * retrieve the synced balance.
     * @return balance The synced balance associated with the legacy lockup.
     */
    function syncBalances(address staker, uint256 legacyLockupIndex) external view returns (uint256 balance);

    /**
     * @notice This function synchronizes a specific legacy lockup index for a
     * user within the contract.  If the legacy lockup.end is not at least
     * `block.timestamp + MIN_SYNC_DURATION()`, this function will revert.
     * @param staker The address of the user for whom to perform synchronization.
     * @param legacyLockupIndex The index of the legacy lockup to be
     * synchronized.
     * @return newBalance The new balance resulting from the synchronization
     * process.
     */
    function sync(address staker, uint256 legacyLockupIndex) external returns (uint256 newBalance);
}

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

import {IMaverickV2Pool} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Pool.sol";

interface IMigrateBins {
    function migrateBinsUpStack(IMaverickV2Pool pool, uint32[] calldata binIds, uint32 maxRecursion) external payable;
}

// SPDX-License-Identifier: GPL-2.0-or-later
// As the copyright holder of this work, Ubiquity Labs retains
// the right to distribute, use, and modify this code under any license of
// their choosing, in addition to the terms of the GPL-v2 or later.
pragma solidity ^0.8.25;

interface IMulticall {
    function multicall(bytes[] calldata data) external returns (bytes[] memory results);
}

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

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

interface INft is IERC721Enumerable {
    /**
     * @notice Check if an NFT exists for a given owner and index.
     */
    function tokenOfOwnerByIndexExists(address owner, uint256 index) external view returns (bool);

    /**
     * @notice Return Id of the next token minted.
     */
    function nextTokenId() external view returns (uint256 nextTokenId_);

    /**
     * @notice Check if the caller has access to a specific NFT by tokenId.
     */
    function checkAuthorized(address spender, uint256 tokenId) external view returns (address owner);

    /**
     * @notice List of tokenIds by owner.
     */
    function tokenIdsOfOwner(address owner) external view returns (uint256[] memory tokenIds);

    /**
     * @notice Get the token URI for a given tokenId.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
}

// SPDX-License-Identifier: GPL-2.0-or-later
// As the copyright holder of this work, Ubiquity Labs retains
// the right to distribute, use, and modify this code under any license of
// their choosing, in addition to the terms of the GPL-v2 or later.
pragma solidity ^0.8.25;

interface IPayableMulticall {
    function multicall(bytes[] calldata data) external payable returns (bytes[] memory results);
}

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

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

import {IPayableMulticall} from "@maverick/v2-common/contracts/base/IPayableMulticall.sol";

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

interface IPayment is IPayableMulticall, IState {
    error PaymentSenderNotWETH9();
    error PaymentInsufficientBalance(address token, uint256 amountMinimum, uint256 contractBalance);

    receive() external payable;

    /**
     * @notice Unwrap WETH9 tokens into ETH and send that balance to recipient.
     * If less than amountMinimum WETH is avialble, then revert.
     */
    function unwrapWETH9(uint256 amountMinimum, address recipient) external payable;

    /**
     * @notice Transfers specified token amount to recipient
     */
    function sweepTokenAmount(IERC20 token, uint256 amount, address recipient) external payable;

    /**
     * @notice Sweep entire ERC20 token balance on this contract to recipient.
     * If less than amountMinimum balance is avialble, then revert.
     */
    function sweepToken(IERC20 token, uint256 amountMinimum, address recipient) external payable;

    /**
     * @notice Send any ETH on this contract to msg.sender.
     */
    function refundETH() external payable;

    /**
     * @notice For tokenA and tokenB, sweep all of the
     * non-WETH tokens to msg.sender.  Any WETH balance is unwrapped to ETH and
     * then all the ETH on this contract is sent to msg.sender.
     */
    function unwrapAndSweep(
        IERC20 tokenA,
        IERC20 tokenB,
        uint256 tokenAAmountMin,
        uint256 tokenBAmountMin
    ) external payable;
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;
import {IMaverickV2Position} from "./IMaverickV2Position.sol";

interface IPositionImage {
    error PositionImageSetPositionError(address sender, address deployer, IMaverickV2Position currentPosition);

    function position() external view returns (IMaverickV2Position _position);
    function setPosition(IMaverickV2Position _position) external;
    function image(uint256 tokenId, address tokenOwner) external view returns (string memory);
}

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

interface IRewardAccounting {
    error InsufficientBalance(uint256 tokenId, uint256 currentBalance, uint256 value);

    /**
     * @notice Balance of stake for a given `tokenId` account.
     */
    function stakeBalanceOf(uint256 tokenId) external view returns (uint256 balance);

    /**
     * @notice Sum of all balances across all tokenIds.
     */
    function stakeTotalSupply() external view returns (uint256 supply);
}

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

interface IRouterErrors {
    error RouterZeroSwap();
    error RouterNotFactoryPool();
    error RouterTooLittleReceived(uint256 amountOutMinimum, uint256 amountOut);
    error RouterTooMuchRequested(uint256 amountInMaximum, uint256 amountIn);
}

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

import {IWETH9} from "./IWETH9.sol";
import {IMaverickV2Factory} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Factory.sol";

interface IState {
    function weth() external view returns (IWETH9 _weth);
    function factory() external view returns (IMaverickV2Factory _factory);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (governance/utils/IVotes.sol)
pragma solidity ^0.8.20;

/**
 * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts.
 */
interface IVotes {
    /**
     * @dev The signature used has expired.
     */
    error VotesExpiredSignature(uint256 expiry);

    /**
     * @dev Emitted when an account changes their delegate.
     */
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /**
     * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of voting units.
     */
    event DelegateVotesChanged(address indexed delegate, uint256 previousVotes, uint256 newVotes);

    /**
     * @dev Returns the current amount of votes that `account` has.
     */
    function getVotes(address account) external view returns (uint256);

    /**
     * @dev Returns the amount of votes that `account` had at a specific moment in the past. If the `clock()` is
     * configured to use block numbers, this will return the value at the end of the corresponding block.
     */
    function getPastVotes(address account, uint256 timepoint) external view returns (uint256);

    /**
     * @dev Returns the total supply of votes available at a specific moment in the past. If the `clock()` is
     * configured to use block numbers, this will return the value at the end of the corresponding block.
     *
     * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.
     * Votes that have not been delegated are still part of total supply, even though they would not participate in a
     * vote.
     */
    function getPastTotalSupply(uint256 timepoint) external view returns (uint256);

    /**
     * @dev Returns the delegate that `account` has chosen.
     */
    function delegates(address account) external view returns (address);

    /**
     * @dev Delegates votes from the sender to `delegatee`.
     */
    function delegate(address delegatee) external;

    /**
     * @dev Delegates votes from signer to `delegatee`.
     */
    function delegateBySig(address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s) external;
}

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

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

interface IWETH9 is IERC20 {
    event Deposit(address indexed dst, uint256 wad);
    event Withdrawal(address indexed src, uint256 wad);

    function deposit() external payable;

    function withdraw(uint256) external;
}

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

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {SafeCast as Cast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";

import {IMaverickV2Pool} from "@maverick/v2-common/contracts/interfaces/IMaverickV2Pool.sol";
import {Math} from "@maverick/v2-common/contracts/libraries/Math.sol";
import {PoolLib} from "@maverick/v2-common/contracts/libraries/PoolLib.sol";
import {ONE, MINIMUM_LIQUIDITY} from "@maverick/v2-common/contracts/libraries/Constants.sol";
import {TickMath} from "@maverick/v2-common/contracts/libraries/TickMath.sol";

import {IMaverickV2PoolLens} from "../interfaces/IMaverickV2PoolLens.sol";
import {IMaverickV2BoostedPosition} from "../interfaces/IMaverickV2BoostedPosition.sol";
import {PoolInspection} from "../libraries/PoolInspection.sol";
import {PackLib} from "../libraries/PackLib.sol";

library LiquidityUtilities {
    using Cast for uint256;

    error LiquidityUtilitiesTargetPriceOutOfBounds(
        uint256 targetSqrtPrice,
        uint256 sqrtLowerTickPrice,
        uint256 sqrtUpperTickPrice
    );
    error LiquidityUtilitiesTooLittleLiquidity(uint256 relativeLiquidityAmount, uint256 deltaA, uint256 deltaB);
    error LiquidityUtilitiesTargetingTokenWithNoDelta(bool targetIsA, uint256 deltaA, uint256 deltaB);
    error LiquidityUtilitiesNoSwapLiquidity();
    error LiquidityUtilitiesFailedToFindDeltaAmounts();
    error LiquidityUtilitiesInitialTargetBTooSmall(
        uint256 initialTargetB,
        uint256 deltaLpBalance,
        uint256 minimumRequiredLpBalance
    );

    uint256 internal constant MIN_DELTA_RESERVES = 100;

    /**
     *
     * @notice Return index into the price breaks array that corresponds to the
     * current pool price.
     *
     * @dev Price break array is N elements [e_0, e_1, ..., e_{n-1}].
     * @dev If price is less than e_0, then `0` is returned, if price is
     * betweeen e_0 and e_1, then `1` is returned, etc.  If the price is
     * between e_{n-2} and e_{n-1}, then n-2 is returned.  If price is larger
     * than e_{n-1}, then n-1 is returned.
     *
     */
    function priceIndexFromPriceBreaks(
        uint256 sqrtPrice,
        bytes memory packedSqrtPriceBreaks
    ) internal pure returns (uint256 index) {
        // index is zero if the pricebreaks array only has one price
        if (packedSqrtPriceBreaks.length == 12) return index;
        uint88[] memory breaks = PackLib.unpackUint88Array(packedSqrtPriceBreaks);

        // loop terminates with `breaks.length - 1` as the max value.
        for (; index < breaks.length - 1; index++) {
            if (sqrtPrice <= breaks[index]) break;
        }
    }

    function tokenScales(IMaverickV2Pool pool) internal view returns (uint256 tokenAScale, uint256 tokenBScale) {
        tokenAScale = pool.tokenAScale();
        tokenBScale = pool.tokenBScale();
    }

    function deltaReservesFromDeltaLpBalanceAtNewPrice(
        IMaverickV2Pool pool,
        int32 tick,
        uint128 deltaLpBalance,
        uint8 kind,
        uint256 newSqrtPrice
    ) internal view returns (uint256 deltaA, uint256 deltaB) {
        PoolLib.AddLiquidityInfo memory addLiquidityInfo;
        uint32 binId = pool.binIdByTickKind(tick, kind);
        IMaverickV2Pool.BinState memory bin = pool.getBin(binId);

        addLiquidityInfo.tickSpacing = pool.tickSpacing();
        addLiquidityInfo.tick = tick;

        IMaverickV2Pool.TickState memory tickState;
        (tickState, addLiquidityInfo.tickLtActive, ) = reservesInTickForGivenPrice(pool, tick, newSqrtPrice);

        PoolLib.deltaTickBalanceFromDeltaLpBalance(
            bin.tickBalance,
            bin.totalSupply,
            tickState,
            deltaLpBalance,
            addLiquidityInfo
        );
        (uint256 tokenAScale, uint256 tokenBScale) = tokenScales(pool);
        deltaA = Math.ammScaleToTokenScale(addLiquidityInfo.deltaA, tokenAScale, true);
        deltaB = Math.ammScaleToTokenScale(addLiquidityInfo.deltaB, tokenBScale, true);
    }

    function deltaReservesFromDeltaLpBalancesAtNewPrice(
        IMaverickV2Pool pool,
        IMaverickV2Pool.AddLiquidityParams memory addParams,
        uint256 newSqrtPrice
    ) internal view returns (IMaverickV2PoolLens.TickDeltas memory tickDeltas) {
        uint256 length = addParams.ticks.length;
        tickDeltas.deltaAs = new uint256[](length);
        tickDeltas.deltaBs = new uint256[](length);
        for (uint256 k; k < length; k++) {
            (tickDeltas.deltaAs[k], tickDeltas.deltaBs[k]) = deltaReservesFromDeltaLpBalanceAtNewPrice(
                pool,
                addParams.ticks[k],
                addParams.amounts[k],
                addParams.kind,
                newSqrtPrice
            );
            tickDeltas.deltaAOut += tickDeltas.deltaAs[k];
            tickDeltas.deltaBOut += tickDeltas.deltaBs[k];
        }
    }

    function scaleAddParams(
        IMaverickV2Pool.AddLiquidityParams memory addParams,
        uint128[] memory ratios,
        uint256 addAmount,
        uint256 targetAmount
    ) internal pure returns (IMaverickV2Pool.AddLiquidityParams memory addParamsScaled) {
        uint256 length = addParams.ticks.length;
        addParamsScaled.ticks = addParams.ticks;
        addParamsScaled.kind = addParams.kind;

        addParamsScaled.amounts = new uint128[](length);

        addParamsScaled.amounts[0] = Math.mulDivFloor(addParams.amounts[0], targetAmount, addAmount).toUint128();
        for (uint256 k = 1; k < length; k++) {
            addParamsScaled.amounts[k] = Math.mulCeil(addParamsScaled.amounts[0], ratios[k]).toUint128();
        }
    }

    function getScaledAddParams(
        IMaverickV2Pool pool,
        IMaverickV2Pool.AddLiquidityParams memory addParams,
        uint128[] memory ratios,
        uint256 newSqrtPrice,
        uint256 targetAmount,
        bool targetIsA
    )
        internal
        view
        returns (
            IMaverickV2Pool.AddLiquidityParams memory addParamsScaled,
            IMaverickV2PoolLens.TickDeltas memory tickDeltas
        )
    {
        // find A and B amount for input addParams
        tickDeltas = deltaReservesFromDeltaLpBalancesAtNewPrice(pool, addParams, newSqrtPrice);
        uint256 unScaledAmount = targetIsA ? tickDeltas.deltaAOut : tickDeltas.deltaBOut;
        if (unScaledAmount == 0) revert LiquidityUtilitiesFailedToFindDeltaAmounts();

        // scale addParams to meet the delta target
        addParamsScaled = scaleAddParams(
            addParams,
            ratios,
            targetIsA ? tickDeltas.deltaAOut : tickDeltas.deltaBOut,
            targetAmount
        );
        tickDeltas = deltaReservesFromDeltaLpBalancesAtNewPrice(pool, addParamsScaled, newSqrtPrice);
    }

    function getAddLiquidityParamsFromRelativeBinLpBalance(
        IMaverickV2PoolLens.BoostedPositionSpecification memory spec,
        int32[] memory ticks,
        IMaverickV2PoolLens.AddParamsSpecification memory params
    )
        internal
        view
        returns (
            bytes memory packedSqrtPriceBreaks,
            bytes[] memory packedArgs,
            uint88[] memory sqrtPriceBreaks,
            IMaverickV2Pool.AddLiquidityParams[] memory addParams,
            IMaverickV2PoolLens.TickDeltas[] memory tickDeltas
        )
    {
        uint256 length = params.numberOfPriceBreaksPerSide * 2 + 1;
        addParams = new IMaverickV2Pool.AddLiquidityParams[](length);
        tickDeltas = new IMaverickV2PoolLens.TickDeltas[](length);

        uint256 sqrtPrice = PoolInspection.poolSqrtPrice(spec.pool);
        addParams[params.numberOfPriceBreaksPerSide].ticks = ticks;
        addParams[params.numberOfPriceBreaksPerSide].amounts = spec.ratios;
        addParams[params.numberOfPriceBreaksPerSide].kind = spec.kind;
        (
            addParams[params.numberOfPriceBreaksPerSide],
            tickDeltas[params.numberOfPriceBreaksPerSide]
        ) = getScaledAddParams(
            spec.pool,
            addParams[params.numberOfPriceBreaksPerSide],
            spec.ratios,
            sqrtPrice,
            params.targetAmount,
            params.targetIsA
        );

        sqrtPriceBreaks = new uint88[](length);
        sqrtPriceBreaks[params.numberOfPriceBreaksPerSide] = sqrtPrice.toUint88();

        // left of price,
        for (uint256 k; k < params.numberOfPriceBreaksPerSide; k++) {
            params.targetIsA = false;
            params.targetAmount = Math.mulDown(tickDeltas[params.numberOfPriceBreaksPerSide].deltaBOut, 0.99999e18);
            if (params.targetAmount == 0) continue;

            // price / (factor + 1), price / (factor * (n-1) / n + 1), price / (factor * (n-2)/n + 1)...
            uint256 factor = Math.mulDivFloor(
                params.slippageFactorD18,
                params.numberOfPriceBreaksPerSide - k,
                params.numberOfPriceBreaksPerSide
            );
            sqrtPriceBreaks[k] = Math.divCeil(sqrtPrice, factor + ONE).toUint88();

            (addParams[k], tickDeltas[k]) = getScaledAddParams(
                spec.pool,
                addParams[params.numberOfPriceBreaksPerSide],
                spec.ratios,
                sqrtPriceBreaks[k],
                params.targetAmount,
                params.targetIsA
            );
        }

        // right of price
        for (uint256 k; k < params.numberOfPriceBreaksPerSide; k++) {
            uint256 index = params.numberOfPriceBreaksPerSide + k + 1;
            params.targetIsA = true;
            params.targetAmount = Math.mulDown(tickDeltas[params.numberOfPriceBreaksPerSide].deltaAOut, 0.99999e18);
            if (params.targetAmount == 0) {
                sqrtPriceBreaks[index - 1] = type(uint88).max;
                break;
            }

            {
                // price * (factor * (1 / n) + 1), price * (factor * (2 / n) + 1), price / (factor * (3 / n) + 1)...
                uint256 factor = Math.mulDivFloor(params.slippageFactorD18, k + 1, params.numberOfPriceBreaksPerSide);
                sqrtPriceBreaks[index] = Math.mulCeil(sqrtPrice, factor + ONE).toUint88();
            }
            (addParams[index], tickDeltas[index]) = getScaledAddParams(
                spec.pool,
                addParams[params.numberOfPriceBreaksPerSide],
                spec.ratios,
                sqrtPriceBreaks[index],
                params.targetAmount,
                params.targetIsA
            );
        }
        sortAddParamsArray(addParams, tickDeltas);
        packedArgs = PackLib.packAddLiquidityArgsArray(addParams);
        packedSqrtPriceBreaks = PackLib.packArray(sqrtPriceBreaks);
    }

    /** @notice Compute add params for N price breaks around price with max right
     * slippage of p * (1 + f) and max left slippage of p / (1 + f).
     *
     * The user specifies the max A and B they are willing to spend.  If the
     * price of the pool does not move, the user will spend exactly this
     * amount. If the price moves left, then the user would like to spend the
     * specified B amount, but will end up spending less A.  Conversely, if the
     * price moves right, the user will spend their max A amount, but less B.
     *
     * By having more break points, we make it so that the user gets as much
     * liquidity as possible at the new price. With too few break points, the
     * user will not have bought as much liquidity as they could have.
     */
    function getAddLiquidityParams(
        IMaverickV2PoolLens.AddParamsViewInputs memory params
    )
        internal
        view
        returns (
            bytes memory packedSqrtPriceBreaks,
            bytes[] memory packedArgs,
            uint88[] memory sqrtPriceBreaks,
            IMaverickV2Pool.AddLiquidityParams[] memory addParams,
            IMaverickV2PoolLens.TickDeltas[] memory tickDeltas
        )
    {
        RelativeLiquidityInput memory input;

        input.poolTickSpacing = params.pool.tickSpacing();
        (input.tokenAScale, input.tokenBScale) = tokenScales(params.pool);
        input.ticks = params.ticks;
        input.relativeLiquidityAmounts = params.relativeLiquidityAmounts;

        uint256 length = params.addSpec.numberOfPriceBreaksPerSide * 2 + 1;
        addParams = new IMaverickV2Pool.AddLiquidityParams[](length);
        tickDeltas = new IMaverickV2PoolLens.TickDeltas[](length);

        // initially target the bigger amount at pool price
        input.targetIsA = params.addSpec.targetIsA;
        input.targetAmount = params.addSpec.targetAmount;
        uint256 startingPrice = PoolInspection.poolSqrtPrice(params.pool);

        input.newSqrtPrice = startingPrice;
        bool success;
        (
            addParams[params.addSpec.numberOfPriceBreaksPerSide],
            tickDeltas[params.addSpec.numberOfPriceBreaksPerSide],
            success
        ) = lpBalanceForArrayOfTargetAmounts(input, params.pool, params.kind);
        if (!success) revert LiquidityUtilitiesFailedToFindDeltaAmounts();
        sqrtPriceBreaks = new uint88[](length);
        sqrtPriceBreaks[params.addSpec.numberOfPriceBreaksPerSide] = input.newSqrtPrice.toUint88();

        // compute slippage price
        // look through N breaks
        // compute deltas
        // convert to addParams
        //

        // left of price,
        for (uint256 k; k < params.addSpec.numberOfPriceBreaksPerSide; k++) {
            input.targetIsA = false;
            input.targetAmount = tickDeltas[params.addSpec.numberOfPriceBreaksPerSide].deltaBOut;

            // price / (factor + 1), price / (factor * (n-1) / n + 1), price / (factor * (n-2)/n + 1)...
            uint256 factor = Math.mulDivFloor(
                params.addSpec.slippageFactorD18,
                params.addSpec.numberOfPriceBreaksPerSide - k,
                params.addSpec.numberOfPriceBreaksPerSide
            );
            sqrtPriceBreaks[k] = Math.divCeil(startingPrice, factor + ONE).toUint88();

            input.newSqrtPrice = sqrtPriceBreaks[k];

            (addParams[k], tickDeltas[k], success) = lpBalanceForArrayOfTargetAmounts(input, params.pool, params.kind);
            if (!success) sqrtPriceBreaks[k] = 0;
        }

        // right of price
        for (uint256 k; k < params.addSpec.numberOfPriceBreaksPerSide; k++) {
            uint256 index = params.addSpec.numberOfPriceBreaksPerSide + k + 1;
            input.targetIsA = true;
            input.targetAmount = tickDeltas[params.addSpec.numberOfPriceBreaksPerSide].deltaAOut;

            // price * (factor * (1 / n) + 1), price * (factor * (2 / n) + 1), price / (factor * (3 / n) + 1)...
            uint256 factor = Math.mulDivFloor(
                params.addSpec.slippageFactorD18,
                k + 1,
                params.addSpec.numberOfPriceBreaksPerSide
            );
            sqrtPriceBreaks[index] = Math.mulCeil(startingPrice, factor + ONE).toUint88();

            input.newSqrtPrice = sqrtPriceBreaks[index];

            (addParams[index], tickDeltas[index], success) = lpBalanceForArrayOfTargetAmounts(
                input,
                params.pool,
                params.kind
            );
            if (!success) {
                sqrtPriceBreaks[index - 1] = type(uint88).max;
                break;
            }
        }
        packedArgs = PackLib.packAddLiquidityArgsArray(addParams);
        packedSqrtPriceBreaks = PackLib.packArray(sqrtPriceBreaks);
    }

    function deltaReservesFromDeltaLiquidity(
        uint256 poolTickSpacing,
        uint256 tokenAScale,
        uint256 tokenBScale,
        int32 tick,
        uint128 deltaLiquidity,
        uint256 tickSqrtPrice
    ) internal pure returns (uint256 deltaA, uint256 deltaB) {
        (uint256 sqrtLowerTickPrice, uint256 sqrtUpperTickPrice) = TickMath.tickSqrtPrices(poolTickSpacing, tick);
        {
            uint256 lowerEdge = Math.max(sqrtLowerTickPrice, tickSqrtPrice);

            deltaB = Math.mulDivCeil(
                deltaLiquidity,
                ONE * Math.clip(sqrtUpperTickPrice, lowerEdge),
                sqrtUpperTickPrice * lowerEdge
            );
        }

        if (tickSqrtPrice < sqrtLowerTickPrice) {
            deltaA = 0;
        } else if (tickSqrtPrice >= sqrtUpperTickPrice) {
            deltaA = Math.mulCeil(deltaLiquidity, sqrtUpperTickPrice - sqrtLowerTickPrice);
            deltaB = 0;
        } else {
            deltaA = Math.mulCeil(
                deltaLiquidity,
                Math.clip(Math.min(sqrtUpperTickPrice, tickSqrtPrice), sqrtLowerTickPrice)
            );
        }
        deltaA = Math.ammScaleToTokenScale(deltaA, tokenAScale, true);
        deltaB = Math.ammScaleToTokenScale(deltaB, tokenBScale, true);
    }

    function deltasFromBinLiquidityAmounts(
        uint256 poolTickSpacing,
        uint256 tokenAScale,
        uint256 tokenBScale,
        int32[] memory ticks,
        uint128[] memory liquidityAmounts,
        uint256 newSqrtPrice
    ) internal pure returns (uint256 deltaA, uint256 deltaB, uint256[] memory deltaAs, uint256[] memory deltaBs) {
        uint256 length = ticks.length;
        deltaAs = new uint256[](length);
        deltaBs = new uint256[](length);
        for (uint256 k = 0; k < length; k++) {
            (deltaAs[k], deltaBs[k]) = deltaReservesFromDeltaLiquidity(
                poolTickSpacing,
                tokenAScale,
                tokenBScale,
                ticks[k],
                liquidityAmounts[k],
                newSqrtPrice
            );
            deltaA += deltaAs[k];
            deltaB += deltaBs[k];
        }
    }

    struct StateInfo {
        uint256 reserveA;
        uint256 reserveB;
        uint256 binTotalSupply;
        int32 activeTick;
    }

    struct RelativeLiquidityInput {
        uint256 poolTickSpacing;
        uint256 tokenAScale;
        uint256 tokenBScale;
        int32[] ticks;
        uint128[] relativeLiquidityAmounts;
        uint256 targetAmount;
        bool targetIsA;
        uint256 newSqrtPrice;
    }

    function _deltasFromRelativeBinLiquidityAmountsAndTargetAmount(
        RelativeLiquidityInput memory input
    ) internal pure returns (IMaverickV2PoolLens.TickDeltas memory output, bool success) {
        uint256 deltaA;
        uint256 deltaB;
        success = true;

        (deltaA, deltaB, output.deltaAs, output.deltaBs) = deltasFromBinLiquidityAmounts(
            input.poolTickSpacing,
            input.tokenAScale,
            input.tokenBScale,
            input.ticks,
            input.relativeLiquidityAmounts,
            input.newSqrtPrice
        );
        uint256 deltaDenominator = input.targetIsA ? deltaA : deltaB;

        if ((input.targetIsA && deltaA == 0) || (!input.targetIsA && deltaB == 0)) return (output, false);

        for (uint256 k; k < input.ticks.length; k++) {
            output.deltaAs[k] = Math
                .mulDivFloor(Math.clip(output.deltaAs[k], 1), input.targetAmount, deltaDenominator)
                .toUint128();
            output.deltaBs[k] = Math
                .mulDivFloor(Math.clip(output.deltaBs[k], 1), input.targetAmount, deltaDenominator)
                .toUint128();
            if (output.deltaAs[k] < MIN_DELTA_RESERVES && output.deltaBs[k] < MIN_DELTA_RESERVES)
                return (output, false);

            output.deltaAOut += output.deltaAs[k];
            output.deltaBOut += output.deltaBs[k];
        }
    }

    function lpBalanceForArrayOfTargetAmountsEmptyPool(
        IMaverickV2PoolLens.TickDeltas memory tickDeltas,
        RelativeLiquidityInput memory input,
        StateInfo memory existingState,
        uint8 kind
    ) internal pure returns (IMaverickV2Pool.AddLiquidityParams memory addParams) {
        addParams.ticks = input.ticks;
        addParams.kind = kind;
        addParams.amounts = new uint128[](input.ticks.length);
        for (uint256 k; k < input.ticks.length; k++) {
            bool tickIsActive = existingState.activeTick == input.ticks[k];
            addParams.amounts[k] = lpBalanceRequiredForTargetReserveAmountsOneBinTick(
                input,
                input.ticks[k],
                Math.tokenScaleToAmmScale(tickDeltas.deltaAs[k], input.tokenAScale),
                Math.tokenScaleToAmmScale(tickDeltas.deltaBs[k], input.tokenBScale),
                tickIsActive ? existingState.reserveA : 0,
                tickIsActive ? existingState.reserveB : 0,
                tickIsActive ? existingState.binTotalSupply : 0,
                input.ticks[k] < existingState.activeTick
            ).toUint128();
        }
    }

    function lpBalanceForArrayOfTargetAmounts(
        RelativeLiquidityInput memory input,
        IMaverickV2Pool pool,
        uint8 kind
    )
        internal
        view
        returns (
            IMaverickV2Pool.AddLiquidityParams memory addParams,
            IMaverickV2PoolLens.TickDeltas memory tickDeltas,
            bool success
        )
    {
        (tickDeltas, success) = _deltasFromRelativeBinLiquidityAmountsAndTargetAmount(input);
        addParams.ticks = input.ticks;
        addParams.kind = kind;

        addParams.amounts = new uint128[](input.ticks.length);
        for (uint256 k; k < input.ticks.length; k++) {
            addParams.amounts[k] = lpBalanceRequiredForTargetReserveAmountsMultiBinTick(
                input,
                pool,
                input.ticks[k],
                kind,
                Math.tokenScaleToAmmScale(tickDeltas.deltaAs[k], input.tokenAScale),
                Math.tokenScaleToAmmScale(tickDeltas.deltaBs[k], input.tokenBScale)
            ).toUint128();
        }
    }

    function donateAndSwapData(
        uint256 poolTickSpacing,
        int32 poolTick,
        uint256 poolFee,
        IERC20 tokenB,
        uint256 targetAmountB,
        uint256 targetSqrtPrice
    ) internal view returns (uint128 deltaLpBalanceB, uint256 swapAmount) {
        uint256 tokenBScale = Math.scale(IERC20Metadata(address(tokenB)).decimals());

        targetAmountB = Math.tokenScaleToAmmScale(targetAmountB, tokenBScale);
        (uint256 sqrtLowerTickPrice, uint256 sqrtUpperTickPrice) = TickMath.tickSqrtPrices(poolTickSpacing, poolTick);

        deltaLpBalanceB = Math.mulFloor(targetAmountB, sqrtUpperTickPrice).toUint128();

        uint256 liquidity = TickMath.getTickL(0, targetAmountB, sqrtLowerTickPrice, sqrtUpperTickPrice);
        if (targetSqrtPrice <= sqrtLowerTickPrice || targetSqrtPrice >= sqrtUpperTickPrice)
            revert LiquidityUtilitiesTargetPriceOutOfBounds(targetSqrtPrice, sqrtLowerTickPrice, sqrtUpperTickPrice);

        swapAmount = Math.mulDivCeil(
            liquidity,
            ONE * (targetSqrtPrice - sqrtLowerTickPrice),
            targetSqrtPrice * sqrtLowerTickPrice
        );
        swapAmount = Math.ammScaleToTokenScale(swapAmount, tokenBScale, true);
        swapAmount = Math.mulCeil(swapAmount, ONE - poolFee);
    }

    function getCreatePoolParams(
        IMaverickV2PoolLens.CreateAndAddParamsViewInputs memory params,
        uint256 protocolFeeRatio
    ) internal view returns (IMaverickV2PoolLens.CreateAndAddParamsInputs memory output) {
        (uint256 sqrtLowerTickPrice, uint256 sqrtUpperTickPrice) = TickMath.tickSqrtPrices(
            params.tickSpacing,
            params.activeTick
        );
        RelativeLiquidityInput memory input;
        StateInfo memory existingState;

        input.poolTickSpacing = params.tickSpacing;
        input.tokenAScale = Math.scale(IERC20Metadata(address(params.tokenA)).decimals());
        input.tokenBScale = Math.scale(IERC20Metadata(address(params.tokenB)).decimals());
        input.ticks = params.ticks;
        input.relativeLiquidityAmounts = params.relativeLiquidityAmounts;
        input.targetAmount = params.targetAmount;
        input.targetIsA = params.targetIsA;
        existingState.activeTick = params.activeTick;

        output.donateParams.ticks = new int32[](1);
        output.donateParams.ticks[0] = params.activeTick;
        output.donateParams.amounts = new uint128[](1);
        if (sqrtLowerTickPrice != params.sqrtPrice) {
            // target price is not tick edge, need to dontate/swap
            (output.donateParams.amounts[0], output.swapAmount) = donateAndSwapData(
                params.tickSpacing,
                params.activeTick,
                params.feeAIn,
                params.tokenB,
                params.initialTargetB,
                params.sqrtPrice
            );

            if (output.donateParams.amounts[0] < MINIMUM_LIQUIDITY)
                revert LiquidityUtilitiesInitialTargetBTooSmall(
                    params.initialTargetB,
                    output.donateParams.amounts[0],
                    MINIMUM_LIQUIDITY
                );
            existingState.binTotalSupply = output.donateParams.amounts[0];

            existingState.reserveB = Math.tokenScaleToAmmScale(
                params.initialTargetB - output.swapAmount,
                input.tokenBScale
            );
            existingState.reserveA = emulateExactOut(
                Math.tokenScaleToAmmScale(output.swapAmount, input.tokenBScale),
                Math.tokenScaleToAmmScale(params.initialTargetB, input.tokenBScale),
                sqrtLowerTickPrice,
                sqrtUpperTickPrice,
                params.feeAIn,
                protocolFeeRatio
            );

            (input.newSqrtPrice, ) = TickMath.getTickSqrtPriceAndL(
                existingState.reserveA,
                existingState.reserveB,
                sqrtLowerTickPrice,
                sqrtUpperTickPrice
            );
        } else {
            input.newSqrtPrice = sqrtLowerTickPrice;
        }

        {
            (
                IMaverickV2PoolLens.TickDeltas memory tickDeltas,
                bool success
            ) = _deltasFromRelativeBinLiquidityAmountsAndTargetAmount(input);
            if (!success) revert LiquidityUtilitiesFailedToFindDeltaAmounts();

            output.addParams = lpBalanceForArrayOfTargetAmountsEmptyPool(tickDeltas, input, existingState, params.kind);
            output.packedAddParams = PackLib.packAddLiquidityArgsToArray(output.addParams);
            output.deltaAOut = tickDeltas.deltaAOut;
            output.deltaBOut = tickDeltas.deltaBOut;
            output.preAddReserveA = existingState.reserveA;
            output.preAddReserveB = existingState.reserveB;
        }
    }

    function emulateExactOut(
        uint256 amountOut,
        uint256 currentReserveB,
        uint256 sqrtLowerTickPrice,
        uint256 sqrtUpperTickPrice,
        uint256 fee,
        uint256 protocolFee
    ) internal pure returns (uint256 amountAIn) {
        uint256 existingLiquidity = TickMath.getTickL(0, currentReserveB, sqrtLowerTickPrice, sqrtUpperTickPrice);

        if (existingLiquidity == 0) revert LiquidityUtilitiesNoSwapLiquidity();

        uint256 binAmountIn = Math.mulDivCeil(
            amountOut,
            sqrtLowerTickPrice,
            Math.invFloor(sqrtLowerTickPrice) - Math.divCeil(amountOut, existingLiquidity)
        );

        // some of the input is fee
        uint256 feeBasis = Math.mulDivCeil(binAmountIn, fee, ONE - fee);
        // fee is added to input amount and just increases bin liquidity
        // out = in / (1-fee)  -> out - fee * out = in  -> out = in + fee * out
        uint256 inWithoutProtocolFee = binAmountIn + feeBasis;
        // add on protocol fee
        amountAIn = protocolFee != 0
            ? Math.clip(inWithoutProtocolFee, Math.mulCeil(feeBasis, protocolFee))
            : inWithoutProtocolFee;
    }

    /**
     * @notice Calculates deltaA = liquidity * (sqrt(upper) - sqrt(lower))
     *  Calculates deltaB = liquidity / sqrt(lower) - liquidity / sqrt(upper),
     *  i.e. liquidity * (sqrt(upper) - sqrt(lower)) / (sqrt(upper) * sqrt(lower))
     */
    function reservesInTickForGivenPrice(
        IMaverickV2Pool pool,
        int32 tick,
        uint256 newSqrtPrice
    ) internal view returns (IMaverickV2Pool.TickState memory tickState, bool tickLtActive, bool tickGtActive) {
        tickState = pool.getTick(tick);
        (uint256 lowerSqrtPrice, uint256 upperSqrtPrice) = TickMath.tickSqrtPrices(pool.tickSpacing(), tick);

        tickGtActive = newSqrtPrice < lowerSqrtPrice;
        tickLtActive = newSqrtPrice >= upperSqrtPrice;

        uint256 liquidity = TickMath.getTickL(tickState.reserveA, tickState.reserveB, lowerSqrtPrice, upperSqrtPrice);

        if (liquidity == 0) {
            (tickState.reserveA, tickState.reserveB) = (0, 0);
        } else {
            uint256 lowerEdge = Math.max(lowerSqrtPrice, newSqrtPrice);

            tickState.reserveA = Math
                .mulCeil(liquidity, Math.clip(Math.min(upperSqrtPrice, newSqrtPrice), lowerSqrtPrice))
                .toUint128();
            tickState.reserveB = Math
                .mulDivCeil(liquidity, ONE * Math.clip(upperSqrtPrice, lowerEdge), upperSqrtPrice * lowerEdge)
                .toUint128();
        }
    }

    function lpBalanceRequiredForTargetReserveAmountsMultiBinTick(
        RelativeLiquidityInput memory input,
        IMaverickV2Pool pool,
        int32 tick,
        uint8 kind,
        uint256 amountAMax,
        uint256 amountBMax
    ) internal view returns (uint256 deltaLpBalance) {
        (IMaverickV2Pool.TickState memory tickState, bool tickLtActive, ) = reservesInTickForGivenPrice(
            pool,
            tick,
            input.newSqrtPrice
        );
        if (tickState.reserveB != 0 || tickState.reserveA != 0) {
            uint256 liquidity;
            {
                (uint256 sqrtLowerTickPrice, uint256 sqrtUpperTickPrice) = TickMath.tickSqrtPrices(
                    input.poolTickSpacing,
                    tick
                );
                liquidity = TickMath.getTickL(
                    tickState.reserveA,
                    tickState.reserveB,
                    sqrtLowerTickPrice,
                    sqrtUpperTickPrice
                );
            }
            uint32 binId = pool.binIdByTickKind(tick, kind);
            IMaverickV2Pool.BinState memory bin = pool.getBin(binId);

            uint256 numerator = Math.max(1, uint256(tickState.totalSupply)) * Math.max(1, uint256(bin.totalSupply));
            if (tickState.reserveA != 0) {
                uint256 denominator = Math.max(1, uint256(bin.tickBalance)) * uint256(tickState.reserveA);
                amountAMax = Math.max(amountAMax, 1);
                deltaLpBalance = Math.mulDivFloor(amountAMax, numerator, denominator);
            } else {
                deltaLpBalance = type(uint256).max;
            }
            if (tickState.reserveB != 0) {
                uint256 denominator = Math.max(1, uint256(bin.tickBalance)) * uint256(tickState.reserveB);
                amountBMax = Math.max(amountBMax, 1);
                deltaLpBalance = Math.min(deltaLpBalance, Math.mulDivFloor(amountBMax, numerator, denominator));
            }
        } else {
            deltaLpBalance = emptyTickLpBalanceRequirement(input, tick, amountAMax, amountBMax, tickLtActive);
        }
    }

    function lpBalanceRequiredForTargetReserveAmountsOneBinTick(
        RelativeLiquidityInput memory input,
        int32 tick,
        uint256 amountAMax,
        uint256 amountBMax,
        uint256 reserveA,
        uint256 reserveB,
        uint256 binTotalSupply,
        bool tickLtActive
    ) internal pure returns (uint256 deltaLpBalance) {
        if (reserveB != 0 || reserveA != 0) {
            deltaLpBalance = Math.min(
                reserveA == 0 ? type(uint256).max : Math.mulDivFloor(amountAMax, binTotalSupply, reserveA),
                reserveB == 0 ? type(uint256).max : Math.mulDivFloor(amountBMax, binTotalSupply, reserveB)
            );
        } else {
            deltaLpBalance = emptyTickLpBalanceRequirement(input, tick, amountAMax, amountBMax, tickLtActive);
        }
    }

    function emptyTickLpBalanceRequirement(
        RelativeLiquidityInput memory input,
        int32 tick,
        uint256 amountAMax,
        uint256 amountBMax,
        bool tickLtActive
    ) internal pure returns (uint256 deltaLpBalance) {
        (uint256 sqrtLowerTickPrice, uint256 sqrtUpperTickPrice) = TickMath.tickSqrtPrices(input.poolTickSpacing, tick);
        if (tickLtActive) {
            deltaLpBalance = Math.divFloor(amountAMax, sqrtLowerTickPrice);
        } else {
            deltaLpBalance = Math.mulFloor(amountBMax, sqrtUpperTickPrice);
        }
    }

    function getBoostedPositionSpec(
        IMaverickV2BoostedPosition boostedPosition
    ) internal view returns (IMaverickV2PoolLens.BoostedPositionSpecification memory spec, int32[] memory ticks) {
        spec.pool = boostedPosition.pool();
        spec.binIds = boostedPosition.getBinIds();
        spec.ratios = boostedPosition.getRatios();
        spec.kind = boostedPosition.kind();
        ticks = boostedPosition.getTicks();
    }

    /**
     * @notice Sort ticks and amounts in addParams struct array in tick order.
     * Mutates input params array in place.
     *
     * @notice Sort operation in this function assumes that all element of the
     * input arrays have the same tick ordering.
     */
    function sortAddParamsArray(
        IMaverickV2Pool.AddLiquidityParams[] memory addParams,
        IMaverickV2PoolLens.TickDeltas[] memory tickDeltas
    ) internal pure {
        uint256 breakPoints = addParams.length;
        uint256 length = addParams[0].ticks.length;
        for (uint256 i = 0; i < length - 1; i++) {
            for (uint256 j = 0; j < length - i - 1; j++) {
                // compare
                if (addParams[0].ticks[j] > addParams[0].ticks[j + 1]) {
                    // if there is a mis-ordering, flip values in all addParam structs
                    for (uint256 k = 0; k < breakPoints; k++) {
                        (addParams[k].ticks[j], addParams[k].ticks[j + 1]) = (
                            addParams[k].ticks[j + 1],
                            addParams[k].ticks[j]
                        );
                        (addParams[k].amounts[j], addParams[k].amounts[j + 1]) = (
                            addParams[k].amounts[j + 1],
                            addParams[k].amounts[j]
                        );
                        (tickDeltas[k].deltaAs[j], tickDeltas[k].deltaAs[j + 1]) = (
                            tickDeltas[k].deltaAs[j + 1],
                            tickDeltas[k].deltaAs[j]
                        );
                        (tickDeltas[k].deltaBs[j], tickDeltas[k].deltaBs[j + 1]) = (
                            tickDeltas[k].deltaBs[j + 1],
                            tickDeltas[k].deltaBs[j]
                        );
                    }
                }
            }
        }
    }
}