slipstream-position-manager

name	Slipstream Position Manager
description	This skill should be used when the user asks about "NonfungiblePositionManager", "NFT", "tokenId", "mint position", "increase liquidity", "decrease liquidity", "multicall", or needs to understand the NFT position wrapper.
version	0.1.0

Slipstream Position Manager

NonfungiblePositionManager wraps concentrated liquidity positions as ERC721 NFTs, providing a user-friendly interface for managing positions.

Overview

┌──────────────────────────────────────────────────────────────┐
│              NONFUNGIBLE POSITION MANAGER                    │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  User ◄─────────────────► Position Manager ◄─────► CLPool   │
│    │                            │                     │      │
│    │  mint()                    │  mint()            │      │
│    │  ─────────────────►        │  ─────────────►    │      │
│    │                            │                     │      │
│    │  ◄───────────────────      │  ◄─────────────    │      │
│    │  NFT (tokenId)             │  callback          │      │
│    │                            │                     │      │
│    │  increaseLiquidity()       │  mint()            │      │
│    │  decreaseLiquidity()       │  burn()            │      │
│    │  collect()                 │  collect()         │      │
│    │                            │                     │      │
│  ┌─────────────────────────────────────────────────────────┐ │
│  │                    NFT Position                         │ │
│  │  ┌─────────────────────────────────────────────────┐    │ │
│  │  │  tokenId: 1234                                  │    │ │
│  │  │  pool: 0x1234...                                │    │ │
│  │  │  tickLower: -100                                │    │ │
│  │  │  tickUpper: 100                                 │    │ │
│  │  │  liquidity: 1000000                             │    │ │
│  │  │  tokensOwed0: 50                                │    │ │
│  │  │  tokensOwed1: 25                                │    │ │
│  │  └─────────────────────────────────────────────────┘    │ │
│  └─────────────────────────────────────────────────────────┘ │
│                                                              │
└──────────────────────────────────────────────────────────────┘

Position Structure

// NonfungiblePositionManager.sol

struct Position {
    uint96 nonce;                          // Permit nonce
    address operator;                       // Approved operator
    uint80 poolId;                          // Pool lookup ID
    int24 tickLower;                        // Range lower bound
    int24 tickUpper;                        // Range upper bound
    uint128 liquidity;                      // Liquidity amount
    uint256 feeGrowthInside0LastX128;      // Token0 fee snapshot
    uint256 feeGrowthInside1LastX128;      // Token1 fee snapshot
    uint128 tokensOwed0;                    // Uncollected token0
    uint128 tokensOwed1;                    // Uncollected token1
}

// Position storage
mapping(uint256 tokenId => Position) private _positions;

// Pool ID to pool data
mapping(uint80 poolId => PoolAddress.PoolKey) private _poolIdToPoolKey;

Mint (Create Position)

struct MintParams {
    address token0;
    address token1;
    int24 tickSpacing;
    int24 tickLower;
    int24 tickUpper;
    uint256 amount0Desired;
    uint256 amount1Desired;
    uint256 amount0Min;
    uint256 amount1Min;
    address recipient;
    uint256 deadline;
    uint160 sqrtPriceX96;  // Optional: create pool if doesn't exist
}

/// @notice Create a new position
/// @return tokenId NFT token ID
/// @return liquidity Liquidity minted
/// @return amount0 Token0 deposited
/// @return amount1 Token1 deposited
function mint(MintParams calldata params)
    external
    payable
    checkDeadline(params.deadline)
    returns (
        uint256 tokenId,
        uint128 liquidity,
        uint256 amount0,
        uint256 amount1
    )
{
    // Get or create pool
    ICLPool pool = ICLPool(
        CLFactory(factory).getPool(params.token0, params.token1, params.tickSpacing)
    );

    if (address(pool) == address(0)) {
        // Create pool with initial price
        pool = ICLPool(
            CLFactory(factory).createPool(
                params.token0,
                params.token1,
                params.tickSpacing,
                params.sqrtPriceX96
            )
        );
    }

    // Add liquidity
    (liquidity, amount0, amount1) = addLiquidity(
        AddLiquidityParams({
            pool: pool,
            recipient: address(this),  // NFT manager holds position
            tickLower: params.tickLower,
            tickUpper: params.tickUpper,
            amount0Desired: params.amount0Desired,
            amount1Desired: params.amount1Desired,
            amount0Min: params.amount0Min,
            amount1Min: params.amount1Min
        })
    );

    // Mint NFT
    _mint(params.recipient, (tokenId = _nextId++));

    // Get fee growth snapshots
    (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128) =
        pool.getFeeGrowthInside(params.tickLower, params.tickUpper);

    // Get or create pool ID
    uint80 poolId = cachePoolKey(
        PoolAddress.PoolKey({token0: params.token0, token1: params.token1, tickSpacing: params.tickSpacing})
    );

    // Store position
    _positions[tokenId] = Position({
        nonce: 0,
        operator: address(0),
        poolId: poolId,
        tickLower: params.tickLower,
        tickUpper: params.tickUpper,
        liquidity: liquidity,
        feeGrowthInside0LastX128: feeGrowthInside0X128,
        feeGrowthInside1LastX128: feeGrowthInside1X128,
        tokensOwed0: 0,
        tokensOwed1: 0
    });

    emit IncreaseLiquidity(tokenId, liquidity, amount0, amount1);
}

Increase Liquidity

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

/// @notice Add liquidity to existing position
function increaseLiquidity(IncreaseLiquidityParams calldata params)
    external
    payable
    checkDeadline(params.deadline)
    returns (uint128 liquidity, uint256 amount0, uint256 amount1)
{
    Position storage position = _positions[params.tokenId];

    PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];
    ICLPool pool = ICLPool(
        PoolAddress.computeAddress(factory, poolKey)
    );

    // Add liquidity
    (liquidity, amount0, amount1) = addLiquidity(
        AddLiquidityParams({
            pool: pool,
            recipient: address(this),
            tickLower: position.tickLower,
            tickUpper: position.tickUpper,
            amount0Desired: params.amount0Desired,
            amount1Desired: params.amount1Desired,
            amount0Min: params.amount0Min,
            amount1Min: params.amount1Min
        })
    );

    // Update fee snapshots and calculate owed
    (
        uint256 feeGrowthInside0X128,
        uint256 feeGrowthInside1X128
    ) = pool.getFeeGrowthInside(position.tickLower, position.tickUpper);

    position.tokensOwed0 += uint128(
        FullMath.mulDiv(
            feeGrowthInside0X128 - position.feeGrowthInside0LastX128,
            position.liquidity,
            FixedPoint128.Q128
        )
    );
    position.tokensOwed1 += uint128(
        FullMath.mulDiv(
            feeGrowthInside1X128 - position.feeGrowthInside1LastX128,
            position.liquidity,
            FixedPoint128.Q128
        )
    );

    position.feeGrowthInside0LastX128 = feeGrowthInside0X128;
    position.feeGrowthInside1LastX128 = feeGrowthInside1X128;
    position.liquidity += liquidity;

    emit IncreaseLiquidity(params.tokenId, liquidity, amount0, amount1);
}

Decrease Liquidity

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

/// @notice Remove liquidity from position
function decreaseLiquidity(DecreaseLiquidityParams calldata params)
    external
    payable
    isAuthorizedForToken(params.tokenId)
    checkDeadline(params.deadline)
    returns (uint256 amount0, uint256 amount1)
{
    require(params.liquidity > 0, "NL");

    Position storage position = _positions[params.tokenId];
    require(position.liquidity >= params.liquidity, "NP");

    PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];
    ICLPool pool = ICLPool(PoolAddress.computeAddress(factory, poolKey));

    // Burn liquidity from pool
    (amount0, amount1) = pool.burn(
        position.tickLower,
        position.tickUpper,
        params.liquidity
    );

    require(amount0 >= params.amount0Min && amount1 >= params.amount1Min, "PS");

    // Update fee snapshots
    (
        uint256 feeGrowthInside0X128,
        uint256 feeGrowthInside1X128
    ) = pool.getFeeGrowthInside(position.tickLower, position.tickUpper);

    position.tokensOwed0 += uint128(
        amount0 +
        FullMath.mulDiv(
            feeGrowthInside0X128 - position.feeGrowthInside0LastX128,
            position.liquidity,
            FixedPoint128.Q128
        )
    );
    position.tokensOwed1 += uint128(
        amount1 +
        FullMath.mulDiv(
            feeGrowthInside1X128 - position.feeGrowthInside1LastX128,
            position.liquidity,
            FixedPoint128.Q128
        )
    );

    position.feeGrowthInside0LastX128 = feeGrowthInside0X128;
    position.feeGrowthInside1LastX128 = feeGrowthInside1X128;
    position.liquidity -= params.liquidity;

    emit DecreaseLiquidity(params.tokenId, params.liquidity, amount0, amount1);
}

Collect

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

/// @notice Collect tokens owed from position
function collect(CollectParams calldata params)
    external
    payable
    isAuthorizedForToken(params.tokenId)
    returns (uint256 amount0, uint256 amount1)
{
    require(params.recipient != address(0), "RA");

    Position storage position = _positions[params.tokenId];

    PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];
    ICLPool pool = ICLPool(PoolAddress.computeAddress(factory, poolKey));

    // Trigger position update to calculate latest fees
    pool.burn(position.tickLower, position.tickUpper, 0);

    // Update fee snapshots
    (
        uint256 feeGrowthInside0X128,
        uint256 feeGrowthInside1X128
    ) = pool.getFeeGrowthInside(position.tickLower, position.tickUpper);

    uint128 tokensOwed0 = position.tokensOwed0 + uint128(
        FullMath.mulDiv(
            feeGrowthInside0X128 - position.feeGrowthInside0LastX128,
            position.liquidity,
            FixedPoint128.Q128
        )
    );
    uint128 tokensOwed1 = position.tokensOwed1 + uint128(
        FullMath.mulDiv(
            feeGrowthInside1X128 - position.feeGrowthInside1LastX128,
            position.liquidity,
            FixedPoint128.Q128
        )
    );

    position.feeGrowthInside0LastX128 = feeGrowthInside0X128;
    position.feeGrowthInside1LastX128 = feeGrowthInside1X128;

    // Cap at owed
    (amount0, amount1) = (
        params.amount0Max > tokensOwed0 ? tokensOwed0 : params.amount0Max,
        params.amount1Max > tokensOwed1 ? tokensOwed1 : params.amount1Max
    );

    // Collect from pool
    (uint128 amount0Collect, uint128 amount1Collect) = pool.collect(
        params.recipient,
        position.tickLower,
        position.tickUpper,
        uint128(amount0),
        uint128(amount1)
    );

    // Update owed
    position.tokensOwed0 = tokensOwed0 - uint128(amount0);
    position.tokensOwed1 = tokensOwed1 - uint128(amount1);

    emit Collect(params.tokenId, params.recipient, amount0Collect, amount1Collect);
}

Burn (Remove NFT)

/// @notice Burn a position NFT
/// @dev Position must have 0 liquidity and 0 tokensOwed
function burn(uint256 tokenId) external payable isAuthorizedForToken(tokenId) {
    Position storage position = _positions[tokenId];
    require(position.liquidity == 0 && position.tokensOwed0 == 0 && position.tokensOwed1 == 0, "NC");

    delete _positions[tokenId];
    _burn(tokenId);
}

Multicall

/// @notice Execute multiple calls in a single transaction
function multicall(bytes[] calldata data) external payable returns (bytes[] memory results) {
    results = new bytes[](data.length);
    for (uint256 i = 0; i < data.length; i++) {
        (bool success, bytes memory result) = address(this).delegatecall(data[i]);

        if (!success) {
            if (result.length < 68) revert();
            assembly {
                result := add(result, 0x04)
            }
            revert(abi.decode(result, (string)));
        }

        results[i] = result;
    }
}

// Example: Mint and stake in one transaction
bytes[] memory calls = new bytes[](2);
calls[0] = abi.encodeCall(nft.mint, (mintParams));
calls[1] = abi.encodeCall(gauge.deposit, (expectedTokenId));
nft.multicall(calls);

Position Query

/// @notice Get position details
function positions(uint256 tokenId)
    external
    view
    returns (
        uint96 nonce,
        address operator,
        address token0,
        address token1,
        int24 tickSpacing,
        int24 tickLower,
        int24 tickUpper,
        uint128 liquidity,
        uint256 feeGrowthInside0LastX128,
        uint256 feeGrowthInside1LastX128,
        uint128 tokensOwed0,
        uint128 tokensOwed1
    )
{
    Position memory position = _positions[tokenId];
    require(position.poolId != 0, "NP");

    PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];

    return (
        position.nonce,
        position.operator,
        poolKey.token0,
        poolKey.token1,
        poolKey.tickSpacing,
        position.tickLower,
        position.tickUpper,
        position.liquidity,
        position.feeGrowthInside0LastX128,
        position.feeGrowthInside1LastX128,
        position.tokensOwed0,
        position.tokensOwed1
    );
}

Events

event IncreaseLiquidity(uint256 indexed tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
event DecreaseLiquidity(uint256 indexed tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
event Collect(uint256 indexed tokenId, address recipient, uint256 amount0, uint256 amount1);

Reference Files

• contracts/periphery/NonfungiblePositionManager.sol - Main contract
• contracts/periphery/base/LiquidityManagement.sol - Add liquidity logic
• contracts/periphery/base/PoolInitializer.sol - Pool creation
• contracts/periphery/base/Multicall.sol - Batch operations