Instructions CLMM

​

Inventaire des instructions

​

CreatePool

sqrt_price_x64: u128           // prix initial
open_time:      u64            // les swaps sont rejetés avant cette heure

• token_mint_0 < token_mint_1 par ordre d’octets.
• amm_config.disable_create_pool == false.
• Les mints ne sont pas rejetés par la liste blanche d’extensions Token-2022.

• pool_state.sqrt_price_x64 = sqrt_price_x64, tick_current = floor(log_{1.0001}(price)).
• pool_state.liquidity = 0 (aucune position pour l’instant).
• pool_state.fee_on = FromInput (valeur par défaut héritée).
• pool_state.dynamic_fee_info est mis à zéro (frais dynamiques désactivés).

​

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 est défini sur la variante CollectFeeOn choisie.
• Si les frais dynamiques sont activés : pool_state.dynamic_fee_info est initialisé à partir du DynamicFeeConfig fourni (cinq paramètres de calibration copiés ; champs d’état mis à zéro).
• Sinon : pool_state.dynamic_fee_info est mis à zéro (= frais dynamiques inactifs de façon permanente pour ce 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 souhaité (ou 0 pour utiliser les montants ci-dessous)
amount_0_max: u64
amount_1_max: u64
with_metadata: bool           // écrire les métadonnées NFT (Metaplex)
base_flag: Option<bool>       // true = ajuster sur amount0 ; false = ajuster sur amount1

• tick_lower < tick_upper, tous deux multiples de pool.tick_spacing, dans [MIN_TICK, MAX_TICK].
• Les tableaux de ticks requis sont passés et initialisés (ou créés ici via un CPI InitTickArray dans la transaction).
• L’utilisateur dispose d’au moins amount_0_max et amount_1_max dans les ATAs sources.

• personal_position existe, liquidity est défini, fee_growth_inside_last est capturé en instantané.
• Les entrées du tableau de ticks à tick_lower et tick_upper sont mises à jour (liquidity_gross += L, liquidity_net ± L, instantanés de croissance des frais maintenus).
• pool_state.liquidity += L si la position est dans la plage (tick_lower ≤ tick_current < tick_upper).

​

IncreaseLiquidityV2

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

• Transfère amount_0_actual / amount_1_actual de l’utilisateur vers les coffres.
• Incrémente personal_position.liquidity et pool_state.liquidity (si dans la plage), ainsi que liquidity_gross / liquidity_net des ticks limites en conséquence.
• Collecte les frais et récompenses dus depuis le dernier accès et les crédite sur tokens_fees_owed_{0,1} / reward_amount_owed. Ces montants ne sont versés que lors d’un DecreaseLiquidity ou d’un CollectReward, pas lors d’une augmentation.

​

DecreaseLiquidityV2

liquidity: u128
amount_0_min: u64
amount_1_min: u64

• Calcule (amount_0, amount_1) pour le L retiré en fonction du sqrt_price_x64 actuel.
• Règle les frais et récompenses accumulés depuis le dernier accès, de la même façon qu’IncreaseLiquidity.
• Transfère amount_0 + fees_owed_0 et amount_1 + fees_owed_1 hors des coffres vers l’utilisateur.
• Décrémente les compteurs de liquidité ; si le nouveau personal_position.liquidity == 0, la position est éligible à ClosePosition.

​

ClosePosition

• personal_position.liquidity == 0.
• tokens_fees_owed_{0,1} == 0.
• Tous les compteurs de récompenses reward_amount_owed == 0.

• Brûle le NFT.
• Ferme le compte de mint du NFT et le compte personal_position, en restituant le loyer au payer.

​

SwapV2

amount: u64                  // entrée si is_base_input=true, sortie sinon
other_amount_threshold: u64  // sortie minimum ou entrée maximum
sqrt_price_limit_x64: u128   // borne dure ; 0 ⇒ sans limite
is_base_input: bool

• pool_state.status autorise le swap.
• now >= open_time.
• sqrt_price_limit_x64 se trouve du bon côté de sqrt_price_x64 pour la direction choisie.

1. Surcharge de frais dynamiques — si pool.dynamic_fee_info est non nul, le programme met à jour l’accumulateur de volatilité en utilisant la distance en ticks parcourue depuis le dernier swap (selon les règles de filtre/décroissance décrites dans products/clmm/fees) et ajoute un dynamic_fee_component au-dessus de AmmConfig.trade_fee_rate. Les frais totaux sont plafonnés à 10 % (MAX_FEE_RATE_NUMERATOR / 1_000_000).
2. Correspondance des ordres limités — lorsque le parcours de prix franchit un tick contenant des ordres limités ouverts, le programme remplit d’abord la liquidité des ordres limités disponibles à ce tick (FIFO par order_phase), puis continue le long de la courbe de liquidité LP. Les montants exécutés mettent à jour tick.unfilled_ratio_x64 et tick.part_filled_orders_remaining pour le règlement ultérieur ; les ordres eux-mêmes restent non dépensés jusqu’à ce que leur propriétaire appelle SettleLimitOrder.
3. Routage des frais unilatéral — lorsque pool.fee_on = Token0Only ou Token1Only, l’étape de swap calcule toujours le même échange entrée-sortie ; les frais sont ensuite acheminés vers le côté configuré. Pour les directions où le côté de frais configuré est la sortie, les frais sont déduits de la sortie du swap (l’utilisateur reçoit out − fee) ; pour les directions où il s’agit de l’entrée, le comportement correspond à FromInput. Voir is_fee_on_input(zero_for_one) et is_fee_on_token0(zero_for_one) sur PoolState.

​

OpenLimitOrder

nonce_index:    u8       // index du compte nonce choisi par l'utilisateur (0..255 par portefeuille)
zero_for_one:   bool     // true : vendre token0 contre token1 ; false : vendre token1 contre token0
tick_index:     i32      // doit être un multiple de pool.tick_spacing
amount:         u64      // montant du token d'entrée

• tick_index % pool.tick_spacing == 0 et dans [MIN_TICK, MAX_TICK].
• tick_index se trouve du bon côté de pool.tick_current pour la direction choisie (vendre token0 → le tick doit être au-dessus du tick actuel, et inversement). Vendre à un tick déjà franchi entraînerait une exécution immédiate et est rejeté.
• pool_state.status autorise l’opération d’ordre limité (bit 5).

• limit_order existe, avec un instantané de tick.order_phase et tick.unfilled_ratio_x64 à l’ouverture.
• tick.orders_amount += amount (dans la cohorte actuelle).
• limit_order_nonce.order_nonce += 1.
• Événement OpenLimitOrderEvent émis.

​

IncreaseLimitOrder

amount: u64    // montant supplémentaire du token d'entrée

• limit_order.owner == signer.
• L’ordre est toujours dans la même cohorte (tick.order_phase == limit_order.order_phase). Si la cohorte a déjà commencé à s’exécuter, l’ordre est partiellement réglé — l’appelant devrait d’abord appeler DecreaseLimitOrder ou SettleLimitOrder pour avancer.

• Transfère amount de l’ATA du propriétaire vers input_vault.
• limit_order.total_amount += amount ; tick.orders_amount += amount.

​

DecreaseLimitOrder

amount:     u64    // montant du token d'entrée à retirer (max = reliquat non exécuté)
amount_min: u64    // plancher de slippage sur le retrait côté entrée

• Recalcule le montant exécuté de l’ordre à partir du unfilled_ratio_x64 de la cohorte depuis l’ouverture.
• Envoie la sortie exécutée vers output_token_account.
• Renvoie amount d’entrée non exécutée vers input_token_account.
• Met à jour limit_order en conséquence. Si le nouveau reliquat non exécuté est nul, le programme ferme le compte et rembourse le loyer au owner.

​

SettleLimitOrder

• Calcule la sortie cumulée due en utilisant (limit_order.unfilled_ratio_x64, tick.unfilled_ratio_x64).
• Transfère le delta vers output_token_account.
• Met à jour limit_order.settled_output.
• Ne ferme pas l’ordre ; il reste ouvert sur toute entrée restante.

​

CloseLimitOrder

• L’ordre a un reliquat non exécuté nul (soit amount == total_amount a été exécuté et réglé, soit le propriétaire avait précédemment réduit l’ordre à zéro sans le fermer).

• Ferme limit_order ; le loyer est envoyé à limit_order.owner.

​

CreateDynamicFeeConfig (admin)

index:                       u16
filter_period:               u16   // secondes ; ex. 30
decay_period:                u16   // secondes ; ex. 600. Doit être > filter_period
reduction_factor:            u16   // 1..10_000 ; ex. 5_000 = 50% de rétention par fenêtre de décroissance
dynamic_fee_control:         u32   // 1..100_000 ; gain sur la courbe volatilité-frais
max_volatility_accumulator:  u32   // plafond

​

UpdateDynamicFeeConfig (admin)

​

CollectProtocolFee / CollectFundFee

​

InitializeReward

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

• Moins de 3 flux actuellement actifs sur le pool.
• Le financeur dépose total_emission = emissions_per_second × (end_time − open_time) de tokens de récompense dans le coffre dans le cadre de cette instruction.
• Mint de récompense autorisé par operation_state.

​

SetRewardParams

​

UpdateRewardInfos

​

CollectReward

• Règle la croissance des récompenses (même mécanisme que pour les frais).
• Transfère le montant dû vers l’ATA destinataire, remet à zéro reward_amount_owed[i].

​

Matrice des changements d’état

​

Pour aller plus loin

• products/clmm/code-demos — exemples TypeScript exécutables.
• products/clmm/fees — détails sur l’accumulation des frais et des récompenses.
• reference/error-codes — tableau complet des erreurs Anchor CLMM.

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