CLMM instructions

​

Instruction inventory

​

CreatePool

sqrt_price_x64: u128           // initial price
open_time:      u64            // swaps rejected before this time

• token_mint_0 < token_mint_1 by byte order.
• amm_config.disable_create_pool == false.
• Mints are not rejected by the Token-2022 extension allow-list.

• pool_state.sqrt_price_x64 = sqrt_price_x64, tick_current = floor(log_{1.0001}(price)).
• pool_state.liquidity = 0 (no positions yet).
• pool_state.fee_on = FromInput (legacy default).
• pool_state.dynamic_fee_info is zeroed (dynamic fee disabled).

​

CreateCustomizablePool

pub struct CreateCustomizableParams {
    pub sqrt_price_x64:    u128,
    pub collect_fee_on:    CollectFeeOn,   // FromInput | Token0Only | Token1Only
    pub enable_dynamic_fee: bool,
}

• pool_state.fee_on set to the chosen CollectFeeOn variant.
• If dynamic fee was enabled: pool_state.dynamic_fee_info is initialized from the supplied DynamicFeeConfig (five calibration parameters copied; state fields zeroed).
• Otherwise: pool_state.dynamic_fee_info is zeroed (= dynamic fee inactive forever for this pool).

​

CreatePermissionedPool

customizable_params: CreateCustomizableParams   // same struct as CreateCustomizablePool
seed_index:          u16                          // must be non-zero; folded into the pool PDA seeds

• seed_index != 0. A seed_index of 0 is reserved for legacy pools and is rejected here; the [0, 0] seed component is what makes a legacy pool address collapse to the classic four-seed form.
• The permission PDA for payer exists (created by an admin via CreatePermissionPda).
• Same mint / allow-list rules as CreatePool.

• A new pool_state exists at the seed_index-derived address, with pool_state.seed_index = seed_index.
• All other post-state matches CreateCustomizablePool (fee mode, optional dynamic fee).

​

OpenPositionV2 / OpenPositionWithToken22Nft

tick_lower_index: i32
tick_upper_index: i32
tick_array_lower_start_index: i32
tick_array_upper_start_index: i32
liquidity:  u128              // desired L (or 0 to use amounts below)
amount_0_max: u64
amount_1_max: u64
with_metadata: bool           // write NFT metadata (Metaplex)
base_flag: Option<bool>       // true = fit to amount0; false = fit to amount1

• tick_lower < tick_upper, both multiples of pool.tick_spacing, within [MIN_TICK, MAX_TICK].
• Required tick arrays passed and initialized (or created here via InitTickArray CPI in the transaction).
• User has at least amount_0_max and amount_1_max in the source ATAs.

• personal_position exists, liquidity set, fee_growth_inside_last snapshotted.
• Tick-array entries at tick_lower and tick_upper updated (liquidity_gross += L, liquidity_net ± L, fee-growth snapshots maintained).
• pool_state.liquidity += L if position is in range (tick_lower ≤ tick_current < tick_upper).
• The position NFT mint records pool_state as freeze authority. Mint authority is removed after the single NFT is minted. Recording the freeze authority does not change the NFT token account’s state.
• The NFT token account remains unfrozen unless the instruction is OpenPositionV2 or OpenPositionWithToken22Nft and either vault mint’s freeze authority matches CLMM’s restricted-issuer list. Only that matching V2 path freezes the account. OpenPosition V1 does not freeze.

​

IncreaseLiquidityV2

liquidity: u128
amount_0_max: u64
amount_1_max: u64
base_flag: Option<bool>

• Transfers amount_0_actual / amount_1_actual from user → vaults.
• Increments personal_position.liquidity and pool_state.liquidity (if in range), and the endpoint-tick liquidity_gross / liquidity_net accordingly.
• Collects fees and rewards owed since last touch and credits them to tokens_fees_owed_{0,1} / reward_amount_owed. Those are paid out only on DecreaseLiquidity or CollectReward, not on increase.

​

DecreaseLiquidityV2

liquidity: u128
amount_0_min: u64
amount_1_min: u64

• Computes (amount_0, amount_1) for the removed L given current sqrt_price_x64.
• Settles fees/rewards accrued since the last touch, same as IncreaseLiquidity.
• Transfers amount_0 + fees_owed_0 and amount_1 + fees_owed_1 out of vaults to the user.
• Decrements liquidity counters; if the new personal_position.liquidity == 0, the position is eligible for ClosePosition.

​

ClosePosition

• Unfrozen NFT: none required; an extra pool account is harmless because the handler does not read it.
• Frozen NFT: append personal_position.pool_id as the first remaining account. The program loads it as PoolState and uses its PDA seeds to sign the thaw.

• personal_position.liquidity == 0.
• tokens_fees_owed_{0,1} == 0.
• All reward counters reward_amount_owed == 0.

• If the NFT token account is frozen, verifies the first remaining account equals personal_position.pool_id, then thaws it with the pool PDA.
• Burns the NFT.
• Closes the NFT token account and personal_position, refunding rent to nft_owner. If the position NFT uses Token-2022, it also closes the NFT mint; classic SPL Token mints cannot be closed and remain with supply zero.

​

SwapV2

amount: u64                  // input if is_base_input=true, output otherwise
other_amount_threshold: u64  // min out or max in
sqrt_price_limit_x64: u128   // hard bound; 0 ⇒ unbounded
is_base_input: bool

• pool_state.status allows swap.
• now >= open_time.
• sqrt_price_limit_x64 is on the correct side of sqrt_price_x64 for the direction.

1. Dynamic fee surcharge — if pool.dynamic_fee_info is non-zero, the program updates the volatility accumulator using the tick distance traversed since the last swap (with the filter/decay rules from products/clmm/fees) and adds a dynamic_fee_component on top of AmmConfig.trade_fee_rate. Total fee is capped at 10% (MAX_FEE_RATE_NUMERATOR / 1_000_000).
2. Limit-order matching — when the price walk crosses a tick that holds open limit orders, the program first fills available limit-order liquidity at that tick (FIFO by order_phase), then proceeds along the LP liquidity curve. Filled amounts update tick.unfilled_ratio_x64 and tick.part_filled_orders_remaining for later settlement; orders themselves remain unspent until their owner calls SettleLimitOrder.
3. Single-sided fee routing — when pool.fee_on = Token0Only or Token1Only, the swap step still computes the same input-output trade; the fee is then routed to the configured side. For directions where the configured fee side is the output, the fee is deducted from the swap output (the user receives out − fee); for directions where it is the input, behavior matches FromInput. See is_fee_on_input(zero_for_one) and is_fee_on_token0(zero_for_one) on PoolState.

​

OpenLimitOrder

nonce_index:    u8       // user's chosen nonce-account index (0..255 per wallet)
zero_for_one:   bool     // true: sell token0 for token1; false: sell token1 for token0
tick_index:     i32      // must be a multiple of pool.tick_spacing
amount:         u64      // input-token amount

• Neither input_token_account nor output_token_account is frozen (else NotApproved).
• pool_state.status allows both the swap (bit 4) and limit-order (bit 5) operations (else NotApproved).
• tick_index % pool.tick_spacing == 0 and within [MIN_TICK, MAX_TICK].
• tick_index is on the right side of pool.tick_current for the chosen direction (selling token0 → tick must be above current, and vice versa). Selling at a tick already crossed would be matched immediately and is rejected.

• limit_order exists, snapshotting tick.order_phase and tick.unfilled_ratio_x64 at open time.
• tick.orders_amount += amount (in the current cohort).
• limit_order_nonce.order_nonce += 1.
• OpenLimitOrderEvent emitted.

​

IncreaseLimitOrder

amount: u64    // additional input-token amount

• limit_order.owner == signer.
• The order is still in the same cohort (tick.order_phase == limit_order.order_phase). If the cohort has already begun filling, the order is partially settled — the caller should call DecreaseLimitOrder or SettleLimitOrder first to roll forward.

• Transfers amount from owner ATA to input_vault.
• limit_order.total_amount += amount; tick.orders_amount += amount.

​

DecreaseLimitOrder

amount:     u64    // input-token amount to withdraw (max = unfilled remainder)
amount_min: u64    // slippage floor on the input-side withdrawal

• Recomputes the order’s filled amount from the cohort’s unfilled_ratio_x64 since open.
• Sends filled output to output_token_account.
• Sends amount of unfilled input back to input_token_account.
• Updates limit_order accordingly. If the new unfilled remainder is zero, the program closes the account and refunds rent to owner.

​

SettleLimitOrder

• Computes the cumulative output owed using (limit_order.unfilled_ratio_x64, tick.unfilled_ratio_x64).
• Transfers the delta to output_token_account.
• Updates limit_order.settled_output.
• Does not close the order; it is still open against any remaining input.

​

CloseLimitOrder

• The order has zero unfilled remainder (either amount == total_amount was filled and settled, or the owner previously decreased the order to zero and forgot to close).

• Closes limit_order; rent is sent to limit_order.owner.

​

CreateDynamicFeeConfig (admin)

index:                       u16
filter_period:               u16   // seconds; e.g. 30
decay_period:                u16   // seconds; e.g. 600. Must be > filter_period
reduction_factor:            u16   // 1..10_000; e.g. 5_000 = 50% retention per decay window
dynamic_fee_control:         u32   // 1..100_000; gain on the volatility-to-fee curve
max_volatility_accumulator:  u32   // ceiling

​

UpdateDynamicFeeConfig (admin)

​

CollectProtocolFee / CollectFundFee

​

InitializeReward

open_time:     u64
end_time:      u64
emissions_per_second_x64: u128   // Q64.64

• Less than 3 streams currently active on the pool.
• Funder deposits total_emission = emissions_per_second × (end_time − open_time) worth of reward token into the vault as part of this instruction.
• Whitelisted reward mint per operation_state.

​

SetRewardParams

​

UpdateRewardInfos

​

CollectReward

• Settles reward growth (same pattern as fees).
• Transfers the owed amount to the recipient ATA, zeroes reward_amount_owed[i].

​

State-change matrix

​

Where to go next

• products/clmm/code-demos — runnable TypeScript samples.
• products/clmm/fees — details on fee and reward accrual.
• reference/error-codes — complete CLMM Anchor error table.

• raydium-io/raydium-clmm — programs/amm/src/instructions
• Raydium SDK v2 — @raydium-io/raydium-sdk-v2