> ## Documentation Index
> Fetch the complete documentation index at: https://tech.ramses.xyz/llms.txt
> Use this file to discover all available pages before exploring further.

# IRamsesV3PositionManager

Wraps Ramses V3 positions in a non-fungible token interface which allows for them to be transferred
and authorized. Extends standard position management with gauge reward claiming.

## Parameter Structs

### MintParams

```solidity theme={null}
  struct MintParams {
        address token0;
        address token1;
        int24 tickSpacing;
        int24 tickLower;
        int24 tickUpper;
        uint256 amount0Desired;
        uint256 amount1Desired;
        uint256 amount0Min;
        uint256 amount1Min;
        address recipient;
        uint256 deadline;
    }
```

### IncreaseLiquidityParams

```solidity theme={null}
   struct IncreaseLiquidityParams {
        uint256 tokenId;
        uint256 amount0Desired;
        uint256 amount1Desired;
        uint256 amount0Min;
        uint256 amount1Min;
        uint256 deadline;
    }
```

### DecreaseLiquidityParams

```solidity theme={null}
    struct DecreaseLiquidityParams {
        uint256 tokenId;
        uint128 liquidity;
        uint256 amount0Min;
        uint256 amount1Min;
        uint256 deadline;
    }
```

### CollectParams

```solidity theme={null}
    struct CollectParams {
        uint256 tokenId;
        address recipient;
        uint128 amount0Max;
        uint128 amount1Max;
    }
```

## Functions

### positions

```solidity theme={null}
  function positions(
    uint256 tokenId
  ) external view returns (address token0, address token1, int24 tickSpacing, int24 tickLower, int24 tickUpper, uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1)
```

Returns the position information associated with a given token ID.

Throws if the token ID is not valid.

#### Parameters:

| Name      | Type    | Description                                      |
| :-------- | :------ | :----------------------------------------------- |
| `tokenId` | uint256 | The ID of the token that represents the position |

#### Return Values:

| Name                       | Type    | Description                                                                      |
| :------------------------- | :------ | :------------------------------------------------------------------------------- |
| `token0`                   | address | The address of the token0 for a specific pool                                    |
| `token1`                   | address | The address of the token1 for a specific pool                                    |
| `tickSpacing`              | int24   | The tick spacing of the pool                                                     |
| `tickLower`                | int24   | The lower end of the tick range for the position                                 |
| `tickUpper`                | int24   | The higher end of the tick range for the position                                |
| `liquidity`                | uint128 | The liquidity of the position                                                    |
| `feeGrowthInside0LastX128` | uint256 | The fee growth of token0 as of the last action on the individual position        |
| `feeGrowthInside1LastX128` | uint256 | The fee growth of token1 as of the last action on the individual position        |
| `tokensOwed0`              | uint128 | The uncollected amount of token0 owed to the position as of the last computation |
| `tokensOwed1`              | uint128 | The uncollected amount of token1 owed to the position as of the last computation |

### createAndInitializePoolIfNecessary

```solidity theme={null}
  function createAndInitializePoolIfNecessary(
    address token0,
    address token1,
    int24 tickSpacing,
    uint160 sqrtPriceX96
  ) external returns (address pool)
```

Creates a new pool if it does not exist, then initializes if not initialized

This method can be bundled with mint for the first mint of a pool to create, initialize a pool and mint at the same time

#### Parameters:

| Name           | Type    | Description                                                  |
| :------------- | :------ | :----------------------------------------------------------- |
| `token0`       | address | The contract address of token0 of the pool                   |
| `token1`       | address | The contract address of token1 of the pool                   |
| `tickSpacing`  | int24   | The tick spacing of the v3 pool for the specified token pair |
| `sqrtPriceX96` | uint160 | The initial square root price of the pool as a Q64.96 value  |

#### Return Values:

| Name   | Type    | Description                                                                                                                    |
| :----- | :------ | :----------------------------------------------------------------------------------------------------------------------------- |
| `pool` | address | Returns the pool address based on the pair of tokens and tick spacing, will return the newly created pool address if necessary |

### mint

```solidity theme={null}
  function mint(
    struct IRamsesV3PositionManager.MintParams params
  ) external returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1)
```

Creates a new position wrapped in a NFT

Call this when the pool does exist and is initialized. Note that if the pool is created but not initialized
a method does not exist, i.e. the pool is assumed to be initialized.

#### Parameters:

| Name     | Type                                       | Description                                                                  |
| :------- | :----------------------------------------- | :--------------------------------------------------------------------------- |
| `params` | struct IRamsesV3PositionManager.MintParams | The params necessary to mint a position, encoded as `MintParams` in calldata |

#### Return Values:

| Name        | Type    | Description                                             |
| :---------- | :------ | :------------------------------------------------------ |
| `tokenId`   | uint256 | The ID of the token that represents the minted position |
| `liquidity` | uint128 | The amount of liquidity for this position               |
| `amount0`   | uint256 | The amount of token0                                    |
| `amount1`   | uint256 | The amount of token1                                    |

### increaseLiquidity

```solidity theme={null}
  function increaseLiquidity(
    struct IRamsesV3PositionManager.IncreaseLiquidityParams params
  ) external returns (uint128 liquidity, uint256 amount0, uint256 amount1)
```

Increases the amount of liquidity in a position, with tokens paid by the `msg.sender`

#### Parameters:

| Name     | Type                                                    | Description                                                         |
| :------- | :------------------------------------------------------ | :------------------------------------------------------------------ |
| `params` | struct IRamsesV3PositionManager.IncreaseLiquidityParams | tokenId The ID of the token for which liquidity is being increased, |

#### Return Values:

| Name        | Type    | Description                                          |
| :---------- | :------ | :--------------------------------------------------- |
| `liquidity` | uint128 | The new liquidity amount as a result of the increase |
| `amount0`   | uint256 | The amount of token0 to achieve resulting liquidity  |
| `amount1`   | uint256 | The amount of token1 to achieve resulting liquidity  |

### decreaseLiquidity

```solidity theme={null}
  function decreaseLiquidity(
    struct IRamsesV3PositionManager.DecreaseLiquidityParams params
  ) external returns (uint256 amount0, uint256 amount1)
```

Decreases the amount of liquidity in a position and accounts it to the position

#### Parameters:

| Name     | Type                                                    | Description                                                        |
| :------- | :------------------------------------------------------ | :----------------------------------------------------------------- |
| `params` | struct IRamsesV3PositionManager.DecreaseLiquidityParams | tokenId The ID of the token for which liquidity is being decreased |

#### Return Values:

| Name      | Type    | Description                            |
| :-------- | :------ | :------------------------------------- |
| `amount0` | uint256 | The amount of token0 sent to recipient |
| `amount1` | uint256 | The amount of token1 sent to recipient |

### collect

```solidity theme={null}
  function collect(
    struct IRamsesV3PositionManager.CollectParams params
  ) external returns (uint256 amount0, uint256 amount1)
```

Collects up to a maximum amount of fees owed to a specific position to the recipient

#### Parameters:

| Name     | Type                                          | Description                                                     |
| :------- | :-------------------------------------------- | :-------------------------------------------------------------- |
| `params` | struct IRamsesV3PositionManager.CollectParams | tokenId The ID of the NFT for which tokens are being collected, |

#### Return Values:

| Name      | Type    | Description                            |
| :-------- | :------ | :------------------------------------- |
| `amount0` | uint256 | The amount of fees collected in token0 |
| `amount1` | uint256 | The amount of fees collected in token1 |

### burn

```solidity theme={null}
  function burn(
    uint256 tokenId
  ) external
```

Burns a token ID, which deletes it from the NFT contract. The token must have 0 liquidity and all tokens
must be collected first.

#### Parameters:

| Name      | Type    | Description                              |
| :-------- | :------ | :--------------------------------------- |
| `tokenId` | uint256 | The ID of the token that is being burned |

### getReward

```solidity theme={null}
  function getReward(
    uint256 tokenId,
    address[] tokens
  ) external
```

Claims gauge rewards for a given position NFT. Ramses-specific.

#### Parameters:

| Name      | Type       | Description                                    |
| :-------- | :--------- | :--------------------------------------------- |
| `tokenId` | uint256    | The ID of the token for which to claim rewards |
| `tokens`  | address\[] | The reward token addresses to claim            |

## Events

### IncreaseLiquidity

```solidity theme={null}
  event IncreaseLiquidity(
    uint256 tokenId,
    uint128 liquidity,
    uint256 amount0,
    uint256 amount1
  )
```

Emitted when liquidity is increased for a position NFT

Also emitted when a token is minted

#### Parameters:

| Name        | Type    | Description                                                      |
| :---------- | :------ | :--------------------------------------------------------------- |
| `tokenId`   | uint256 | The ID of the token for which liquidity was increased            |
| `liquidity` | uint128 | The amount by which liquidity for the NFT position was increased |
| `amount0`   | uint256 | The amount of token0 that was paid for the increase in liquidity |
| `amount1`   | uint256 | The amount of token1 that was paid for the increase in liquidity |

### DecreaseLiquidity

```solidity theme={null}
  event DecreaseLiquidity(
    uint256 tokenId,
    uint128 liquidity,
    uint256 amount0,
    uint256 amount1
  )
```

Emitted when liquidity is decreased for a position NFT

#### Parameters:

| Name        | Type    | Description                                                           |
| :---------- | :------ | :-------------------------------------------------------------------- |
| `tokenId`   | uint256 | The ID of the token for which liquidity was decreased                 |
| `liquidity` | uint128 | The amount by which liquidity for the NFT position was decreased      |
| `amount0`   | uint256 | The amount of token0 that was accounted for the decrease in liquidity |
| `amount1`   | uint256 | The amount of token1 that was accounted for the decrease in liquidity |

### Collect

```solidity theme={null}
  event Collect(
    uint256 tokenId,
    address recipient,
    uint256 amount0,
    uint256 amount1
  )
```

Emitted when tokens are collected for a position NFT

The amounts reported may not be exactly equivalent to the amounts transferred, due to rounding behavior

#### Parameters:

| Name        | Type    | Description                                                    |
| :---------- | :------ | :------------------------------------------------------------- |
| `tokenId`   | uint256 | The ID of the token for which underlying tokens were collected |
| `recipient` | address | The address of the account that received the collected tokens  |
| `amount0`   | uint256 | The amount of token0 owed to the position that was collected   |
| `amount1`   | uint256 | The amount of token1 owed to the position that was collected   |