Instrucciones CLMM

Documentation Index

Fetch the complete documentation index at: https://docs.raydium.io/llms.txt

Use this file to discover all available pages before exploring further.

​

Inventario de instrucciones

​

CreatePool

sqrt_price_x64: u128           // precio inicial
open_time:      u64            // los swaps se rechazan antes de este tiempo

• token_mint_0 < token_mint_1 por orden de bytes.
• amm_config.disable_create_pool == false.
• Los mints no están rechazados por la lista de permitidos de extensiones Token-2022.

• pool_state.sqrt_price_x64 = sqrt_price_x64, tick_current = floor(log_{1.0001}(price)).
• pool_state.liquidity = 0 (sin posiciones todavía).
• pool_state.fee_on = FromInput (valor predeterminado heredado).
• pool_state.dynamic_fee_info se inicializa en cero (comisión dinámica desactivada).

​

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 se establece según la variante CollectFeeOn elegida.
• Si se activó la comisión dinámica: pool_state.dynamic_fee_info se inicializa desde el DynamicFeeConfig proporcionado (se copian los cinco parámetros de calibración; los campos de estado se ponen a cero).
• De lo contrario: pool_state.dynamic_fee_info se pone a cero (= comisión dinámica inactiva permanentemente para este pool).

​

OpenPositionV2 / OpenPositionWithToken22Nft

tick_lower_index: i32
tick_upper_index: i32
tick_array_lower_start_index: i32
tick_array_upper_start_index: i32
liquidity:  u128              // L deseado (o 0 para usar los amounts siguientes)
amount_0_max: u64
amount_1_max: u64
with_metadata: bool           // escribir metadatos del NFT (Metaplex)
base_flag: Option<bool>       // true = ajustar a amount0; false = ajustar a amount1

• tick_lower < tick_upper, ambos múltiplos de pool.tick_spacing, dentro de [MIN_TICK, MAX_TICK].
• Los tick arrays requeridos se pasan y están inicializados (o se crean aquí vía CPI InitTickArray en la transacción).
• El usuario tiene al menos amount_0_max y amount_1_max en las ATAs de origen.

• personal_position existe, liquidity establecido, fee_growth_inside_last registrado como instantánea.
• Las entradas del tick array en tick_lower y tick_upper se actualizan (liquidity_gross += L, liquidity_net ± L, instantáneas de crecimiento de comisiones mantenidas).
• pool_state.liquidity += L si la posición está en rango (tick_lower ≤ tick_current < tick_upper).

​

IncreaseLiquidityV2

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

• Transfiere amount_0_actual / amount_1_actual del usuario a los vaults.
• Incrementa personal_position.liquidity y pool_state.liquidity (si está en rango), así como liquidity_gross / liquidity_net de los ticks extremos.
• Cobra las comisiones y recompensas pendientes desde el último toque y las acredita en tokens_fees_owed_{0,1} / reward_amount_owed. Estos montos solo se pagan en DecreaseLiquidity o CollectReward, no al incrementar.

​

DecreaseLiquidityV2

liquidity: u128
amount_0_min: u64
amount_1_min: u64

• Calcula (amount_0, amount_1) para el L retirado dado el sqrt_price_x64 actual.
• Liquida las comisiones y recompensas acumuladas desde el último toque, igual que IncreaseLiquidity.
• Transfiere amount_0 + fees_owed_0 y amount_1 + fees_owed_1 de los vaults al usuario.
• Decrementa los contadores de liquidez; si el nuevo personal_position.liquidity == 0, la posición es elegible para ClosePosition.

​

ClosePosition

• personal_position.liquidity == 0.
• tokens_fees_owed_{0,1} == 0.
• Todos los contadores de recompensas reward_amount_owed == 0.

• Quema el NFT.
• Cierra la cuenta del mint del NFT y la cuenta personal_position, devolviendo el alquiler al payer.

​

SwapV2

amount: u64                  // entrada si is_base_input=true, salida en caso contrario
other_amount_threshold: u64  // mínimo de salida o máximo de entrada
sqrt_price_limit_x64: u128   // límite estricto; 0 ⇒ sin límite
is_base_input: bool

• pool_state.status permite el swap.
• now >= open_time.
• sqrt_price_limit_x64 está en el lado correcto de sqrt_price_x64 según la dirección.

1. Recargo por comisión dinámica — si pool.dynamic_fee_info es distinto de cero, el programa actualiza el acumulador de volatilidad usando la distancia en ticks recorrida desde el último swap (con las reglas de filtrado/decaimiento de products/clmm/fees) y suma un dynamic_fee_component sobre AmmConfig.trade_fee_rate. La comisión total está limitada al 10% (MAX_FEE_RATE_NUMERATOR / 1_000_000).
2. Coincidencia de órdenes límite — cuando el recorrido de precio cruza un tick que tiene órdenes límite abiertas, el programa primero completa la liquidez de las órdenes límite disponibles en ese tick (FIFO por order_phase) y luego continúa por la curva de liquidez LP. Los amounts ejecutados actualizan tick.unfilled_ratio_x64 y tick.part_filled_orders_remaining para liquidación posterior; las órdenes permanecen sin pagar hasta que su dueño llame a SettleLimitOrder.
3. Enrutamiento de comisión unilateral — cuando pool.fee_on = Token0Only o Token1Only, el paso del swap calcula el mismo intercambio entrada-salida; la comisión se enruta luego al lado configurado. En las direcciones donde el lado de comisión configurado es la salida, la comisión se deduce del output del swap (el usuario recibe out − fee); en las direcciones donde es la entrada, el comportamiento coincide con FromInput. Ver is_fee_on_input(zero_for_one) y is_fee_on_token0(zero_for_one) en PoolState.

​

OpenLimitOrder

nonce_index:    u8       // índice de cuenta-nonce elegido por el usuario (0..255 por wallet)
zero_for_one:   bool     // true: vender token0 por token1; false: vender token1 por token0
tick_index:     i32      // debe ser múltiplo de pool.tick_spacing
amount:         u64      // cantidad del token de entrada

• tick_index % pool.tick_spacing == 0 y dentro de [MIN_TICK, MAX_TICK].
• tick_index está en el lado correcto de pool.tick_current para la dirección elegida (al vender token0 → el tick debe estar por encima del actual, y viceversa). Vender en un tick ya cruzado se ejecutaría de inmediato y es rechazado.
• pool_state.status permite la operación de orden límite (bit 5).

• limit_order existe, registrando tick.order_phase y tick.unfilled_ratio_x64 al momento de apertura.
• tick.orders_amount += amount (en la cohorte actual).
• limit_order_nonce.order_nonce += 1.
• Se emite OpenLimitOrderEvent.

​

IncreaseLimitOrder

amount: u64    // cantidad adicional del token de entrada

• limit_order.owner == signer.
• La orden sigue en la misma cohorte (tick.order_phase == limit_order.order_phase). Si la cohorte ya comenzó a ejecutarse, la orden está parcialmente liquidada: el caller debería llamar primero a DecreaseLimitOrder o SettleLimitOrder para avanzar.

• Transfiere amount desde la ATA del dueño al input_vault.
• limit_order.total_amount += amount; tick.orders_amount += amount.

​

DecreaseLimitOrder

amount:     u64    // cantidad del token de entrada a retirar (máx. = remanente sin ejecutar)
amount_min: u64    // piso de slippage en el retiro del lado de entrada

• Recalcula el amount ejecutado de la orden a partir del unfilled_ratio_x64 de la cohorte desde la apertura.
• Envía el output ejecutado a output_token_account.
• Devuelve amount de la entrada sin ejecutar a input_token_account.
• Actualiza limit_order en consecuencia. Si el nuevo remanente sin ejecutar es cero, el programa cierra la cuenta y devuelve el alquiler al owner.

​

SettleLimitOrder

• Calcula el output acumulado adeudado usando (limit_order.unfilled_ratio_x64, tick.unfilled_ratio_x64).
• Transfiere el delta a output_token_account.
• Actualiza limit_order.settled_output.
• No cierra la orden; sigue abierta frente a cualquier entrada restante.

​

CloseLimitOrder

• La orden tiene remanente sin ejecutar igual a cero (ya sea porque amount == total_amount fue ejecutado y liquidado, o porque el dueño redujo previamente la orden a cero y olvidó cerrarla).

• Cierra limit_order; el alquiler se envía a limit_order.owner.

​

CreateDynamicFeeConfig (admin)

index:                       u16
filter_period:               u16   // segundos; p. ej. 30
decay_period:                u16   // segundos; p. ej. 600. Debe ser > filter_period
reduction_factor:            u16   // 1..10_000; p. ej. 5_000 = 50% de retención por ventana de decaimiento
dynamic_fee_control:         u32   // 1..100_000; ganancia en la curva volatilidad-comisión
max_volatility_accumulator:  u32   // techo

​

UpdateDynamicFeeConfig (admin)

​

CollectProtocolFee / CollectFundFee

​

InitializeReward

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

• Menos de 3 flujos activos actualmente en el pool.
• El financiador deposita total_emission = emissions_per_second × (end_time − open_time) en tokens de recompensa en el vault como parte de esta instrucción.
• Mint de recompensa en la lista blanca según operation_state.

​

SetRewardParams

​

UpdateRewardInfos

​

CollectReward

• Liquida el crecimiento de recompensas (mismo patrón que las comisiones).
• Transfiere el monto adeudado a la ATA destinataria, poniendo reward_amount_owed[i] a cero.

​

Matriz de cambios de estado

​

Siguientes pasos

• products/clmm/code-demos — ejemplos ejecutables en TypeScript.
• products/clmm/fees — detalles sobre el cálculo de comisiones y recompensas.
• reference/error-codes — tabla completa de errores Anchor de CLMM.

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