Cuentas de CLMM

Todas las cuentas que utiliza un pool de CLMM: PoolState, AmmConfig, TickArrayState, TickArrayBitmapExtension, PersonalPositionState y Observation.

Esta página describe la estructura y el papel de cada cuenta. Las seeds son canónicas y aparecen listadas en reference/program-addresses. Un pool de CLMM tiene más cuentas que uno de CPMM, porque la liquidez se almacena de forma dispersa a lo largo del rango de ticks; entender esa dispersión es la parte principal de esta página.

​

Inventario de cuentas

Un pool de CLMM activo se describe mediante las siguientes familias de cuentas. Todas son propiedad del programa de CLMM, salvo las dos mints y sus vaults.

Cuenta	Función	Cantidad por pool
AmmConfig	Nivel de comisiones: tasa de comisión de trading, porción del protocolo, porción del fondo y tick-spacing por defecto. Compartida por todos los pools de este nivel.	1 (compartida)
PoolState	sqrt_price_x64 actual, tick actual, liquidez total, valores globales de crecimiento de comisiones, información de recompensas y puntero de observaciones.	1
TickArrayState	Un bloque de TICK_ARRAY_SIZE ticks adyacentes. Solo se inicializa cuando se necesita.	0 ≤ N ≤ rango
TickArrayBitmapExtension	Mapa de bits de desbordamiento que indica qué tick arrays existen más allá del mapa de bits en línea de PoolState.	0 o 1
PersonalPositionState	Una por posición de LP. Guarda el rango, la liquidez y el último crecimiento de comisiones/recompensas observado. Autoridad = propietario del NFT.	1 por posición
Mint del NFT de posición	Mint con suministro 1, asociado a PersonalPositionState. Su token account no está congelada por defecto; una apertura V2 solo la congela cuando alguna de las mints subyacentes coincide con el filtro de emisores restringidos.	1 por posición
ObservationState	Buffer circular de observaciones de precio para el TWAP.	1
token_0_vault, token_1_vault	Token accounts que contienen los saldos del pool. Propiedad de la autoridad del pool.	2
DynamicFeeConfig	Conjunto de parámetros reutilizable para el mecanismo de comisiones dinámicas. Los pools creados con create_customizable_pool pueden activarlo. Gestionada por el administrador.	compartida (por índice)
LimitOrderState	Una por orden límite abierta. Registra propietario, tick, lado, cantidad total y una instantánea del importe liquidado.	1 por orden
LimitOrderNonce	Contador por (wallet, nonce_index) que deriva PDAs de orden únicas.	1 por (wallet, índice)

​

PoolState

El estado en vivo del pool, que se lee en cada swap y en cada cambio de posición.

// programs/amm/src/states/pool.rs
pub struct PoolState {
    pub bump:           [u8; 1],
    pub amm_config:     Pubkey,            // vinculación al nivel de comisiones
    pub owner:          Pubkey,            // administrador (multisig)
    pub token_mint_0:   Pubkey,
    pub token_mint_1:   Pubkey,
    pub token_vault_0:  Pubkey,
    pub token_vault_1:  Pubkey,
    pub observation_key: Pubkey,

    pub mint_decimals_0: u8,
    pub mint_decimals_1: u8,
    pub tick_spacing:   u16,               // heredado de amm_config en la inicialización

    pub liquidity:      u128,              // liquidez activa total (dentro del rango)
    pub sqrt_price_x64: u128,              // Q64.64 de sqrt(precio)
    pub tick_current:   i32,               // índice del tick actual

    pub padding3:       u16,
    pub padding4:       u16,

    // Crecimiento global de comisiones por unidad de liquidez, Q64.64.
    pub fee_growth_global_0_x64: u128,
    pub fee_growth_global_1_x64: u128,

    // Comisiones del protocolo acumuladas y no retiradas (por mint).
    pub protocol_fees_token_0: u64,
    pub protocol_fees_token_1: u64,

    // Relleno reservado para futuras actualizaciones.
    pub padding5: [u128; 4],

    // Máscara de estado. Bits 0-5: apertura de posición, reducción de liquidez,
    // cobro de comisiones, cobro de recompensas, swap y orden límite. Un bit
    // activado deshabilita la operación correspondiente.
    pub status:  u8,

    // Modo de cobro de comisiones (CollectFeeOn).
    //   0 = FromInput (deduce la comisión del input del swap; valor por defecto de Uniswap-V3)
    //   1 = Token0Only (deduce siempre la comisión del vault de token0)
    //   2 = Token1Only (deduce siempre la comisión del vault de token1)
    pub fee_on: u8,

    // Índice proporcionado por el cliente (u16 LE) que se incorpora a las seeds
    // de la PDA del pool mediante create_customizable_pool_v2. [0, 0] para pools
    // creados con CreatePool / CreateCustomizablePool (el componente de la seed
    // queda vacío).
    pub seed_index: [u8; 2],
    pub padding: [u8; 4],

    // Flujos de recompensas activos (hasta REWARD_NUM = 3).
    pub reward_infos: [RewardInfo; 3],

    // Mapa de bits en línea que registra los tick-arrays inicializados en el rango principal.
    pub tick_array_bitmap: [u64; 16],

    // Relleno reservado para futuras actualizaciones.
    pub padding6: [u64; 4],

    pub fund_fees_token_0: u64,
    pub fund_fees_token_1: u64,

    pub open_time:    u64,                 // actualmente deshabilitado por el programa
    pub recent_epoch: u64,

    // Estado de comisiones dinámicas del pool. Valores a cero salvo que el pool
    // se haya creado con `enable_dynamic_fee = true` mediante create_customizable_pool.
    pub dynamic_fee_info: DynamicFeeInfo,

    // Reservado para futuras actualizaciones.
    pub padding1: [u64; 14],
    pub padding2: [u64; 32],
}

Campos que realmente vas a utilizar:

• sqrt_price_x64 y tick_current constituyen el estado de precio del pool. Se actualizan juntos en cada swap. tick_current es el suelo de log_{1.0001}(precio).
• liquidity es la liquidez activa: la suma de los valores de L de todas las posiciones cuyo rango contiene tick_current. Cambia cada vez que un swap cruza un tick y cada vez que una posición se abre, se cierra o se redimensiona.
• fee_growth_global_{0,1}_x64 son las comisiones acumuladas por unidad de liquidez a lo largo de todo el historial del pool. Las posiciones las leen para calcular lo que se les debe.
• tick_spacing queda fijado al AmmConfig en la inicialización y nunca cambia. Determina qué índices de tick pueden usarse como extremos de una posición.
• tick_array_bitmap es un mapa de bits en línea que cubre el rango de ticks habitual alrededor del precio spot. En pools cuyas posiciones se alejan mucho, el seguimiento de desbordamiento se encuentra en la cuenta independiente TickArrayBitmapExtension.
• fee_on se fija al crear el pool. 0 (FromInput) reproduce el comportamiento clásico de Uniswap-V3. 1 y 2 dirigen la comisión del swap a un único lado del pool; consulta products/clmm/fees para conocer las ventajas y desventajas de cada opción.
• seed_index es [0, 0] en todos los pools creados mediante CreatePool / CreateCustomizablePool (un pool canónico por par). Un valor distinto de cero indica que el pool se creó con CreateCustomizablePoolV2 (llamada CreatePermissionedPool antes del 22/10/2026) y que el índice forma parte de las seeds de la PDA, lo que permite que varios pools coexistan para el mismo (config, mint0, mint1). Para recalcular la dirección de un pool así necesitas conocer su seed_index.
• dynamic_fee_info contiene el estado de volatilidad para el recargo de comisiones dinámicas. Cuando está activado, cada swap recalcula un dynamic_fee_component sobre AmmConfig.trade_fee_rate. La estructura se documenta en DynamicFeeInfo, más abajo; los pools sin comisiones dinámicas dejan toda la estructura a cero.

​

AmmConfig

pub struct AmmConfig {
    pub bump: u8,
    pub index: u16,                       // usa la seed "amm_config"+u16

    pub owner:             Pubkey,        // propietario de las comisiones del protocolo (CollectProtocolFee)
    pub protocol_fee_rate: u32,           // fracción de la comisión de trading para el protocolo, denominador 1e6
    pub trade_fee_rate:    u32,           // comisión de trading en millonésimas del volumen (1e6)
    pub tick_spacing:      u16,           // espaciado por defecto para los pools que usan esta configuración
    pub fund_fee_rate:     u32,           // fracción de la comisión de trading para el fondo, denominador 1e6
    pub padding_u32: u32,

    pub fund_owner: Pubkey,               // propietario de las comisiones del fondo (CollectFundFee)
    pub padding: [u64; 3],
}

Desde la actualización de 09/2026, CreateAmmConfig escribe la clave codificada en el programa protocol_fee_owner::ID en owner, y fund_fee_owner::ID en fund_owner. Antes de esa fecha, copiaba en ambos campos la clave del firmante administrador. Las configuraciones existentes conservan los valores con los que se crearon o a los que se rotaron, así que lee ambos campos directamente de la cuenta. Los parámetros 3 / 4 de UpdateAmmConfig siguen permitiendo rotarlos. Las direcciones están en reference/program-addresses.

Un conjunto típico de niveles de comisiones de CLMM publicado (confírmalo consultando GET https://api-v3.raydium.io/main/clmm-config):

Índice	trade_fee_rate	Tick spacing	Uso habitual
0	100 (0,01 %)	1	Pares estables, USDC/USDT
1	500 (0,05 %)	10	Blue chips correlacionados
2	2_500 (0,25 %)	60	Pares estándar
3	10_000 (1,00 %)	120	Volátiles o de cola larga

protocol_fee_rate y fund_fee_rate son fracciones de la comisión de trading, con la misma convención que en CPMM. Consulta products/clmm/fees.

​

TickArrayState

CLMM no guarda un registro por cada tick, porque eso supondría miles de millones de cuentas. En su lugar, agrupa TICK_ARRAY_SIZE ticks contiguos, inicializados o no (normalmente 60 u 88, según la versión del programa) en un TickArrayState que se crea de forma perezosa en el primer uso.

pub const TICK_ARRAY_SIZE: usize = 60;
pub const TICK_ARRAY_SIZE_USIZE: usize = 60;

pub struct TickArrayState {
    pub pool_id:                Pubkey,
    pub start_tick_index:       i32,                            // lowest tick in this array
    pub ticks:                  [TickState; TICK_ARRAY_SIZE],   // 60 entries
    pub initialized_tick_count: u8,
    pub recent_epoch:           u64,
    pub padding:                [u8; 107],
}

pub struct TickState {
    pub tick:                       i32,
    pub liquidity_net:              i128,                       // ΔL when crossing this tick upward
    pub liquidity_gross:            u128,                       // total L referencing this tick
    pub fee_growth_outside_0_x64:   u128,                       // see math.mdx
    pub fee_growth_outside_1_x64:   u128,
    pub reward_growths_outside_x64: [u128; 3],

    // Limit-order bookkeeping. All zero for ticks that have never carried
    // a limit order. See products/clmm/math for the matching algorithm.
    pub order_phase:                  u64,                      // monotonic FIFO cohort id
    pub orders_amount:                u64,                      // unfilled tokens in current cohort
    pub part_filled_orders_remaining: u64,                      // remaining tokens of partially-filled cohort
    pub unfilled_ratio_x64:           u128,                     // Q64.64; starts at 1.0 and shrinks as fills occur

    pub padding:                    [u32; 3],
}

Los cuatro campos de órdenes límite valen cero en cualquier tick que nunca se haya usado para una orden límite. Cuando se abren órdenes en un tick, el programa las gestiona como una secuencia de cohortes:

• order_phase es el identificador de la cohorte. Se incrementa cada vez que una cohorte pasa de «totalmente sin ejecutar» a «parcialmente ejecutada».
• orders_amount es el total de tokens de entrada de la cohorte actual (la más reciente).
• part_filled_orders_remaining registra la cohorte anterior, que se sigue ejecutando con los swaps en curso.
• unfilled_ratio_x64 es un multiplicador Q64.64 asociado a la cohorte: cuando un swap ejecuta el X % de la cohorte, el ratio se multiplica por (1 − X). Cada orden abierta guarda su propia instantánea (order_phase, unfilled_ratio_x64) en el momento de abrirse, de modo que el cálculo de liquidación se reduce a comparar instantáneas.

Reglas:

• Un extremo de posición t debe cumplir t % tick_spacing == 0. El programa rechaza las posiciones que no se ajusten al espaciado.
• El array del tick se encuentra en floor(t / (TICK_ARRAY_SIZE * tick_spacing)) * (TICK_ARRAY_SIZE * tick_spacing).
• Un tick array se inicializa de forma perezosa: la primera posición o swap que toque un array sin inicializar lo crea y paga la renta.
• El programa nunca cierra un tick array. Una vez asignado, permanece durante toda la vida del pool, incluso cuando todos sus ticks vuelven a liquidity_gross == 0. Las posiciones y swaps posteriores reutilizan la cuenta existente sin coste adicional de renta. No existe una ruta de limpieza de tick arrays asociada a ClosePosition.

​

TickArrayBitmapExtension

PoolState.tick_array_bitmap (en línea) cubre el rango «cercano al precio spot»: ±512 tick arrays (TICK_ARRAY_BITMAP_SIZE = 512; el campo [u64; 16] tiene 1.024 bits repartidos por igual entre índices de inicio negativos y positivos, de modo que los índices de array van de −512 a +511). Fuera de ese rango (para valores de tick extremos), el programa mantiene una cuenta de extensión:

pub struct TickArrayBitmapExtension {
    pub pool_id: Pubkey,
    pub positive_tick_array_bitmap: [[u64; 8]; 14],
    pub negative_tick_array_bitmap: [[u64; 8]; 14],
}

Si el rango de tu posición es «normal», nunca tendrás que preocuparte por la cuenta de extensión. Las posiciones de rango completo (por ejemplo, (MIN_TICK, MAX_TICK)) sí la necesitan, pero el SDK la resuelve por ti.

​

Posiciones

Una posición de CLMM es un conjunto de tres cuentas más un mint:

​

Mint del NFT de posición

Un mint de SPL Token o Token-2022 con supply 1. El NFT de posición en la cartera del propietario es un ATA que contiene ese único token. El programa asocia la autorización al titular actual del saldo del ATA del NFT, no a una Pubkey almacenada en el estado.

Los nuevos mints de NFT de posición establecen pool_state como su autoridad de congelación antes de acuñar el único token y de eliminar la autoridad de mint. Establecer una autoridad de congelación no congela por sí mismo la cuenta del NFT. La cuenta permanece descongelada y transferible, salvo que se cumplan ambas condiciones: el llamador usa OpenPositionV2 u OpenPositionWithToken22Nft, y la autoridad de congelación de al menos un mint de los vaults subyacentes aparece en la lista de emisores restringidos de CLMM. Solo entonces CLMM congela la cuenta del NFT tras acuñarlo. Esto no modifica ningún byte de PersonalPositionState ni de PoolState.

​

PersonalPositionState

Una por cada posición abierta. Se indexa a partir del mint del NFT.

pub struct PersonalPositionState {
    pub bump: [u8; 1],
    pub nft_mint: Pubkey,                 // this position's NFT mint
    pub pool_id:  Pubkey,

    pub tick_lower_index: i32,
    pub tick_upper_index: i32,

    pub liquidity: u128,                  // this position's L

    // Fee-growth snapshots at last time the position was touched.
    pub fee_growth_inside_0_last_x64: u128,
    pub fee_growth_inside_1_last_x64: u128,
    pub token_fees_owed_0: u64,           // accrued since last collect
    pub token_fees_owed_1: u64,

    pub reward_infos: [PositionRewardInfo; 3],
    pub recent_epoch: u64,
    pub padding: [u64; 7],
}

pub struct PositionRewardInfo {
    pub growth_inside_last_x64: u128,
    pub reward_amount_owed: u64,
}

​

ProtocolPositionState (obsoleto)

Las versiones anteriores de CLMM guardaban una contabilidad agregada por (pool, tick_lower, tick_upper) en una PDA ProtocolPositionState. Las versiones más recientes ya no crean ni leen esta cuenta. El slot sigue apareciendo en las listas de cuentas de OpenPosition, IncreaseLiquidity y DecreaseLiquidity como UncheckedAccount por compatibilidad con la ABI, pero el programa no escribe en él. Las cuentas existentes en la cadena son vestigiales; el administrador puede llamar a CloseProtocolPosition para recuperar la renta de ellas.

La contabilidad agregada del rango ahora se deriva directamente de los dos ticks extremos (liquidity_gross, liquidity_net y los campos fee_growth_outside_* / reward_growths_outside_x64 de cada tick) en TickArrayState. La fórmula de crecimiento de comisiones dentro del rango, fee_growth_inside = global − outside_lower − outside_upper, sigue funcionando sin una cuenta de posición agregada.

​

Observación

pub const OBSERVATION_NUM: usize = 100;

pub struct Observation {
    pub block_timestamp: u32,
    pub tick_cumulative: i64,                            // Σ tick_current × Δt
    pub padding:         [u64; 4],
}

pub struct ObservationState {
    pub initialized:       bool,
    pub recent_epoch:      u64,
    pub observation_index: u16,
    pub pool_id:           Pubkey,
    pub observations:      [Observation; OBSERVATION_NUM], // 100 entries
    pub padding:           [u64; 4],
}

El búfer de observaciones de CLMM almacena un tick acumulado, no un precio acumulado. Los consumidores externos calculan el precio de media geométrica en un intervalo a partir de (tick_cumulative[t1] − tick_cumulative[t0]) / (t1 − t0) y después price = 1.0001 ** tick. Véase algorithms/clmm-math.

​

DynamicFeeConfig y DynamicFeeInfo

Los parámetros de comisión dinámica viven en dos lugares. La plantilla reutilizable, DynamicFeeConfig, es gestionada por el administrador y se comparte entre los pools que la activan. El estado de ejecución de cada pool, DynamicFeeInfo, va incrustado en PoolState y se actualiza en cada swap.

​

DynamicFeeConfig

// programs/amm/src/states/pool_fee.rs
pub struct DynamicFeeConfig {
    pub index:                       u16,    // identifier; PDA seed component
    pub filter_period:               u16,    // seconds — within this window the volatility reference is held
    pub decay_period:                u16,    // seconds — beyond this window the reference fully decays
    pub reduction_factor:            u16,    // fixed-point in [1, 10_000); applied at decay
    pub dynamic_fee_control:         u32,    // fixed-point in (0, 100_000); fee-rate gain
    pub max_volatility_accumulator:  u32,    // ceiling on the volatility accumulator
    pub padding:                     [u64; 8],
}

Semilla de la PDA: ["dynamic_fee_config", index.to_be_bytes()]. Se crea mediante create_dynamic_fee_config (restringido al administrador) y se modifica mediante update_dynamic_fee_config. Un pool creado con enable_dynamic_fee = true copia los cinco parámetros de calibración de la configuración (filter_period, decay_period, reduction_factor, dynamic_fee_control, max_volatility_accumulator) en su propio DynamicFeeInfo en el momento de la creación; las ediciones posteriores de DynamicFeeConfig no afectan retroactivamente a los pools existentes.

​

DynamicFeeInfo (incrustado en PoolState)

pub struct DynamicFeeInfo {
    pub filter_period:                u16,
    pub decay_period:                 u16,
    pub reduction_factor:             u16,
    pub dynamic_fee_control:          u32,
    pub max_volatility_accumulator:   u32,
    pub tick_spacing_index_reference: i32,    // tick-spacing-units; reference for next swap
    pub volatility_reference:         u32,    // running floor for the accumulator
    pub volatility_accumulator:       u32,    // current cumulative volatility (capped)
    pub last_update_timestamp:        u64,
    pub padding:                      [u8; 46],
}

Los cuatro campos inferiores son estado; los cinco superiores son la calibración copiada de DynamicFeeConfig. La fórmula de comisiones y las reglas de decaimiento se documentan en products/clmm/math y products/clmm/fees.

Constantes usadas por la fórmula:

Constante	Valor	Significado
VOLATILITY_ACCUMULATOR_SCALE	10_000	Granularidad del acumulador de volatilidad
REDUCTION_FACTOR_DENOMINATOR	10_000	Denominador de reduction_factor
DYNAMIC_FEE_CONTROL_DENOMINATOR	100_000	Denominador de dynamic_fee_control
MAX_FEE_RATE_NUMERATOR	100_000	Límite máximo del 10 % sobre la tasa de comisión resultante

​

LimitOrderState

Una cuenta por cada orden límite abierta.

// programs/amm/src/states/limit_order.rs
pub struct LimitOrderState {
    pub pool_id:            Pubkey,
    pub owner:              Pubkey,
    pub tick_index:         i32,
    pub zero_for_one:       bool,    // direction: true sells token0 for token1
    pub order_phase:        u64,     // snapshot of TickState.order_phase at open time
    pub total_amount:       u64,     // input-token amount placed
    pub filled_amount:      u64,     // informational; computed precisely on settle
    pub settle_base:        u64,     // unfilled remainder at last settle/decrease
    pub settled_output:     u64,     // cumulative output-token paid to owner
    pub open_time:          u64,
    pub unfilled_ratio_x64: u128,    // Q64.64 snapshot of TickState.unfilled_ratio_x64 at open
    pub padding:            [u64; 4],
}

Ciclo de vida:

1. Apertura: el usuario llama a open_limit_order y deposita total_amount del token de entrada; la orden queda vinculada a una cohorte de TickState.
2. (Opcional) Aumentar / reducir: increase_limit_order añade al total_amount; decrease_limit_order devuelve los tokens no ejecutados (y cualquier salida liquidada hasta ese momento).
3. Liquidación: cuando la cohorte se ejecuta total o parcialmente, el propietario o el keeper operativo llama a settle_limit_order para enviar los tokens de salida al ATA del propietario.
4. Cierre: una vez que unfilled_amount == 0, la cuenta puede cerrarse. La renta siempre se devuelve a owner.

Semilla de la PDA: [owner.as_ref(), limit_order_nonce.key().as_ref(), limit_order_nonce.order_nonce.to_be_bytes().as_ref()]. Por tanto, la PDA de la orden es única para cada combinación (owner, nonce_index, order_nonce).

​

LimitOrderNonce

Contador por (wallet, nonce_index) que permite a un mismo usuario ejecutar varias canalizaciones paralelas de órdenes límite sin que se produzcan colisiones de PDA.

pub struct LimitOrderNonce {
    pub user_wallet: Pubkey,
    pub nonce_index: u8,             // user-chosen, 0..255
    pub order_nonce: u64,            // monotonic, incremented every time a new order is opened
    pub padding:     [u64; 4],
}

Semilla del PDA: [user_wallet.as_ref(), &[nonce_index]]. La mayoría de los clientes usan nonce_index = 0 y dejan que order_nonce lleve la cuenta de las órdenes.

​

Permission (retirada)

La cuenta Permission se eliminó con la actualización del 2026-10-22. Antes se usaba para restringir CreatePermissionedPool, que ahora es CreateCustomizablePoolV2, sin permisos previos. El programa ya no lee ni cierra estas cuentas, y las instrucciones CreatePermissionPda y ClosePermissionPda han desaparecido. Los PDA creados antes de la actualización (["permission", authority], 280 bytes) siguen en la cadena como datos inertes; ignórelos al revisar las cuentas propiedad de CLMM.

​

Derivación de las cuentas clave

import { PublicKey } from "@solana/web3.js";

const CLMM_PROGRAM_ID = new PublicKey(
  "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK"
); // see reference/program-addresses

function i32ToBytes(n: number): Buffer {
  const b = Buffer.alloc(4);
  b.writeInt32BE(n);
  return b;
}

export function deriveClmmAccounts(
  ammConfig: PublicKey,
  token0Mint: PublicKey,           // must already be sorted
  token1Mint: PublicKey,
) {
  const [poolState] = PublicKey.findProgramAddressSync(
    [Buffer.from("pool"), ammConfig.toBuffer(),
     token0Mint.toBuffer(), token1Mint.toBuffer()],
    CLMM_PROGRAM_ID,
  );
  // NOTE: pools created via CreateCustomizablePoolV2 append a non-zero u16
  // seed_index (LE) as a 5th seed — see deriveCustomizablePoolV2 below.
  const [observation] = PublicKey.findProgramAddressSync(
    [Buffer.from("observation"), poolState.toBuffer()],
    CLMM_PROGRAM_ID,
  );
  const [tickArrayBitmapExtension] = PublicKey.findProgramAddressSync(
    [Buffer.from("pool_tick_array_bitmap_extension"), poolState.toBuffer()],
    CLMM_PROGRAM_ID,
  );
  return { poolState, observation, tickArrayBitmapExtension };
}

export function deriveTickArray(
  pool: PublicKey,
  startTickIndex: number,
) {
  const [tickArray] = PublicKey.findProgramAddressSync(
    [Buffer.from("tick_array"), pool.toBuffer(), i32ToBytes(startTickIndex)],
    CLMM_PROGRAM_ID,
  );
  return tickArray;
}

export function deriveDynamicFeeConfig(index: number) {
  const idx = Buffer.alloc(2);
  idx.writeUInt16BE(index);
  const [pda] = PublicKey.findProgramAddressSync(
    [Buffer.from("dynamic_fee_config"), idx],
    CLMM_PROGRAM_ID,
  );
  return pda;
}

export function deriveCustomizablePoolV2(
  ammConfig: PublicKey,
  token0Mint: PublicKey,           // must already be sorted
  token1Mint: PublicKey,
  seedIndex: number,               // non-zero u16
) {
  const idx = Buffer.alloc(2);
  idx.writeUInt16LE(seedIndex);    // little-endian, unlike the u16 seeds above
  const [pool] = PublicKey.findProgramAddressSync(
    [Buffer.from("pool"), ammConfig.toBuffer(),
     token0Mint.toBuffer(), token1Mint.toBuffer(), idx],
    CLMM_PROGRAM_ID,
  );
  return pool;
}

export function deriveLimitOrderNonce(
  wallet: PublicKey,
  nonceIndex: number,
) {
  const [pda] = PublicKey.findProgramAddressSync(
    [wallet.toBuffer(), Buffer.from([nonceIndex & 0xff])],
    CLMM_PROGRAM_ID,
  );
  return pda;
}

export function deriveLimitOrder(
  wallet: PublicKey,
  nonceAccount: PublicKey,
  orderNonce: bigint,
) {
  const nonceBytes = Buffer.alloc(8);
  nonceBytes.writeBigUInt64BE(orderNonce);
  const [pda] = PublicKey.findProgramAddressSync(
    [wallet.toBuffer(), nonceAccount.toBuffer(), nonceBytes],
    CLMM_PROGRAM_ID,
  );
  return pda;
}

export function derivePersonalPosition(nftMint: PublicKey) {
  const [personalPosition] = PublicKey.findProgramAddressSync(
    [Buffer.from("position"), nftMint.toBuffer()],
    CLMM_PROGRAM_ID,
  );
  return personalPosition;
}

Las cadenas exactas de las semillas deben verificarse siempre contra el IDL en la cadena y en reference/program-addresses.

​

Guía rápida del ciclo de vida

Evento	Cuentas creadas	Cuentas destruidas
CreatePool	poolState, observation, token_0_vault, token_1_vault	—
OpenPosition[V2] / OpenPositionWithToken22Nft	Mint del NFT + ATA, personalPosition, posiblemente nuevos tickArrayState, tickArrayBitmapExtension si aún no existen; puede congelar el ATA del NFT en un pool con emisor restringido	—
IncreaseLiquidity	Posiblemente nuevos tickArrayState	—
DecreaseLiquidity	—	Posiblemente limpia entradas de tick (pero la tickArrayState en sí no se cierra)
ClosePosition	—	ATA del NFT, personalPosition y el mint del NFT Token-2022; un mint de NFT SPL clásico permanece con suministro cero. La ruta congelada primero descongela mediante el pool pasado en las cuentas restantes.
SwapV2	Posiblemente nuevos tickArrayState	—
OpenLimitOrder	limitOrderState, posiblemente limitOrderNonce (init-if-needed), posiblemente nuevos tickArrayState	—
IncreaseLimitOrder	—	—
DecreaseLimitOrder	—	Cierra limitOrderState si la orden se consume por completo
SettleLimitOrder	—	—
CloseLimitOrder	—	limitOrderState (renta → owner)
CreateDynamicFeeConfig	dynamicFeeConfig	—
CreateCustomizablePool	poolState, observation, vaults: igual que CreatePool. Captura dynamicFeeConfig si enable_dynamic_fee = true.	—
CreateCustomizablePoolV2	poolState (en una dirección derivada de seed_index), observation, vaults: igual que CreateCustomizablePool. Sin permisos.	—
CollectRewards	—	—
UpdateRewardInfos	—	—
CloseProtocolPosition (admin)	—	protocolPositionState vestigial (renta → admin)

Las cuentas TickArrayState nunca las cierra el programa: persisten durante toda la vida del pool. Una vez inicializado un tick array, permanece en la cadena aunque todos los ticks que contiene vuelvan a liquidity_gross == 0. Reutilizar un tick array existente no tiene coste; solo la primera posición que toca un array nunca inicializado paga su renta.

​

Dónde leer cada tema

• Matemáticas de ticks y mecánica de rangos: products/clmm/ticks-and-positions.
• Recorrido de swaps y matemáticas de crecimiento de comisiones: products/clmm/math.
• Listas de cuentas de cada instrucción: products/clmm/instructions.
• Comisiones y acumulación de recompensas: products/clmm/fees.
• IDs canónicos de programa y semillas: reference/program-addresses.

Fuentes:

• raydium-io/raydium-clmm — programs/amm/src/states